#!/bin/bash
#
# source BaseEnvHelper.sh or source ArgsHelper.sh to use
# used to help other scripts to make their args organized
# invoke 'SetRequestedArg' / 'SetDescription' / 'SetExample' first
# then invoke 'VerifyAllArgs "$@"'
set -e
source ${HOME}/env-setup/env-helper/ColorStyleHelper.sh
# create empty arrays to store arguments with corresponding names
# shortNameArray to store shortName and so on
shortNameArray=()
fullNameArray=()
exampleNameArray=() # used to store [$shortName $fullName] together to output when argUsage() called
ifOptionalArray=()
argDescriptionArray=()
ifAcceptValueArray=()
validValueArray=()
ifMultipleArray=()
# it's VERY likely to create an array with non-continuous indices when VerfiyAllArgs() is called
# one or more indices may be 'jumped' over when one or more optional args are NOT passed-in
# so ONLY passed-in args and values are verified and then put into validPassedInValueArray
validPassedInArgArray=()
validPassedInValueArray=()
# call anywhere inside worker script after VerifyAllArgs() was called
# example and description are skipped
PukeMeOut() {
local size=${#shortNameArray[*]}
declare -i i=1 # skip [--help HELP_ARG]
ifAll=$1
while [ "$size" -gt "$i" ]; do
if [ "$ifAll" == true ]; then # puke all build-in arrays and items
if [ -z "${validPassedInValueArray[$i]}" ]; then
validPassedInArgArray[$i]='None'
validPassedInValueArray[$i]='None'
fi
# exampleName and exampleNameArray are skipped cause they already have styles
echo -e "${_COLOR_D}\
shortName: [${shortNameArray[$i]}] \
| fullName: [${fullNameArray[$i]}] \
| ifOptional: [${ifOptionalArray[$i]}] \
| argDescription: [${argDescriptionArray[$i]}] \
| ifAcceptValue: [${ifAcceptValueArray[$i]}] \
| validValue: [${validValueArray[$i]}] \
| ifMultiple: [${ifMultipleArray[$i]}] \
| validPassedInArg: [${validPassedInArgArray[$i]}] \
| validPassedInValue: [${validPassedInValueArray[$i]}]\
${_END}"
else # puke only arrays and itmes related to passed-in args
if [ -z "${validPassedInValueArray[$i]}" ]; then
i=$i+1
continue
fi
echo -e "${_COLOR_D}\
validPassedInArg: [${validPassedInArgArray[$i]}] \
| fullName: [${fullNameArray[$i]}] \
| ifOptional: [${ifOptionalArray[$i]}] \
| ifAcceptValue: [${ifAcceptValueArray[$i]}] \
| validValue: [${validValueArray[$i]}] \
| ifMultiple: [${ifMultipleArray[$i]}] \
| validPassedInValue: [${validPassedInValueArray[$i]}]\
${_END}"
fi
i=$i+1
done
}
description= # not an array
exampleArray=()
exampleDescArray=()
# invoke SetRequestedArg() multiple times to setup a list of required args
SetRequestedArg() {
# 0 at the 1st time, increases by 1 on each invocation
# so value can be set at correct index of target array
argNum=${#shortNameArray[*]}
# two examples:
# 1. SetRequestedArg "-c" "true" "COMPRESS_FILE" "if compress the output file" "true" "zip tar.gz"
# valid: '-c zip' or not passed-in, invalid: '-c bzip2'
#
# 2. SetRequestedArg "-os" "false" "OS_NAME" "name of operating system" "true" "win7 win10 win2008r2 win2012r2" "true"
# valid: '-os "win7 win2k8r2"', invalid: '-os "win8 win10"' or not passed-in
shortName=$1 # arg short name, used when call from command line, like '-c' or '-os'
ifOptional=$2 # if optional or mendatory, 'true' or 'false'
fullName=$3 # arg full name, used in script which sources ArgsHelper, like 'COMPRESS_FILE' or 'OS_NAME'
argDescription=$4 # arg description, describe what is the arg used for
ifAcceptValue=$5 # if accepta passing value from command line, 'true' or 'false' (false means the arg is like a switch, can be turned on or off)
validValue=$6 # a list of valid values, used to validate passed-in values, like 'zip tar.gz' or 'win7 win10 win2008r2 win2012r2'
ifMultiple=$7 # if arg can be passed-in multi-values, multi-values needs double quotes, see examples above
# 'accepts value' means 'mendatory', so only 'optoinal' arg can accept no value
if [ "$ifOptional" == "false" -a "$ifAcceptValue" == "false" ]; then
echo -e "\n${_ERROR}ERROR: only optional arg can be set not to accept value${_END}"
echo -e "${_ERROR}please re-define arg [$shortName $fullName] and try again${_END}"
exit 100
fi
if [ "$shortName" == "--help" ]; then
exampleName="${_B}${_COLOR_A}[$shortName]${_END}"
else
exampleName="${_B}${_COLOR_A}$shortName${_END} ${_UL}${_COLOR_A}$fullName${_END}"
[ "$ifOptional" == "true" ] && exampleName="${_COLOR_A}[${_END}${exampleName} ${_COLOR_A}(optional)]${_END}"
[ "$ifAcceptValue" == "false" ] && exampleName="${exampleName} ${_COLOR_A}(not accepts value)${_END}"
fi
shortNameArray[$argNum]=$shortName
fullNameArray[$argNum]=$fullName
ifOptionalArray[$argNum]=$ifOptional
argDescriptionArray[$argNum]=$argDescription
ifAcceptValueArray[$argNum]=$ifAcceptValue
exampleNameArray[$argNum]=$exampleName
validValueArray[$argNum]=$validValue
ifMultipleArray[$argNum]=$ifMultiple
}
SetDescription() {
description=$1
}
# example and its description
# if need to use customized format, like
# example:
# info1
# info2
# info3
# just set 'exampleArray' but leave 'exampleDescArray' empty, like
# SetExample "example:\n info1\n info2\n info3" ""
SetExample() {
argNum=${#exampleArray[*]}
exampleArray[$argNum]="$1"
exampleDescArray[$argNum]="$2"
}
# will be invoked on each ERROR in 'shortMode', and '--help' with every details
argUsage() {
argNum=${#shortNameArray[*]}
exampleNum=${#exampleArray[*]}
# create a brief argUsage with script name and arg list
declare -i i=0
while [ "$argNum" -gt "$i" ]; do
argList="$argList ${exampleNameArray[$i]}"
i=$i+1
done
if [ "$1" == "short" ]; then
echo -e "\n${_COLOR_A}argUsage${_END}:$argList"
echo -e "${_COLOR_A}run '$villain --help' for more details${_END}"
else # display every details if not 'shortMode'
if [ -n "$preLogs" ]; then
echo -e "${_COLOR_D}----------------------------------------------------------------------------${_END}"
echo -e "${_COLOR_D} Functions called before ${FUNCNAME}:${_END}"
for preLog in $preLogs; do
echo -e "${_COLOR_D} ${preLog}${_END}"
done
echo -e "${_COLOR_D}----------------------------------------------------------------------------${_END}"
fi
echo -e "\n${_4S}${_COLOR_A}argUsage:${_END}$argList"
echo -e "${_4S}${_COLOR_D}$description${_END}\n"
declare -i i=0
while [ "$argNum" -gt "$i" ]; do
echo -e "${_4S}${exampleNameArray[$i]}" # '[-c COMPRESS_FILE]'
echo -e "${_4S}${_4S}${_COLOR_B}${argDescriptionArray[$i]}${_END}" # '(optional) if compress the output file'
if [ "${ifAcceptValueArray[$i]}" == "true" ]; then
if [ ! -z "${validValueArray[$i]}" ]; then
if [ "${ifMultipleArray[$i]}" == "true" ]; then # 'Valid values: [win7 win10 win2008r2 win2012r2]'
echo -e "${_4S}${_4S}${_COLOR_B}valid values: [${validValueArray[$i]}]\
\n${_4S}${_4S}single('') or double(\"\") quotes required if multi-values passed-in${_END}"
else
echo -e "${_4S}${_4S}${_COLOR_B}valid value: [${validValueArray[$i]}]${_END}" # 'Valid value: [zip tar.gz]'
fi
else
echo -e "${_4S}${_4S}${_COLOR_B}accepts any value (validation needs be done in worker script)${_END}" # 'Valid value: [zip tar.gz]'
fi
fi
i=$i+1
done
if [ "$exampleNum" -gt 0 ]; then
echo -e "\n${_4S}${_COLOR_C}Examples:${_END}"
declare -i i=0
while [ "$exampleNum" -gt "$i" ]; do
echo -e "${_4S}${_4S}${_COLOR_D}${exampleArray[$i]}${_END}"
echo -e "${_2S}${_4S}${_4S}${_COLOR_D}${exampleDescArray[$i]}${_END}\n"
i=$i+1
done
fi
fi
}
# exceptions=(noArgs), for now only one type of exception
# make an exception when some scripts need NO args to run
MakeException() {
exception=$1
}
# used to check if required arg(s) are passed-in
# call "CheckArgBinds '-c XYZ' '-a -b'" inside the beginning of a function
# or code block before doing real work
CheckArgBinds() {
local action=$1
local binds=$2
for bind in $binds; do # check each required arg is passed-in
local shortName=${bind%:*}
if [[ ! "${validPassedInArgArray[@]}" =~ "$shortName" ]]; then
echo -e "${_ERROR}ERROR: Arguments Binds validation falied. [$action] requires [${bind/:/ }] to pass-in${_END}"
exit 11
fi
done
}
# useful if want to output log for functions called before argUsage() or VerifyAllArgs()
# cause some values of args need to be generated before worker scripts actually run
preRunningLog=''
SetPreRunningLogs() {
preRunningLog="${preRunningLog} ${1}"
}
# verify all args passed in, invoked by: 'VerifyAllArgs "$@"'
VerifyAllArgs() {
if [ "$#" -eq 0 ] && [ "$exception" != 'noArgs' ]; then
echo -e "\n${_ERROR}ERROR: no arguments passed-in${_END}"
argUsage short
exit 11
fi
if [ "$1" == "--help" ]; then
argUsage # display every details if the 1st arg is '--help'
exit 0
fi
echo -e "\n${_COLOR_D}----------------------------------------------------------------------------${_END}"
if [ -n "$preRunningLog" ]; then
echo -e "${_COLOR_D} Functions called before ${FUNCNAME}:${_END}"
for preLog in $preRunningLog; do
echo -e "${_COLOR_D} ${preLog}${_END}"
done
echo ""
fi
# print info of which worker script runs on which host with what arguments
# will be useful if called by other script from remote
echo -e "${_COLOR_D} On Host [`hostname`] run full invocation as:${_END}"
echo -e "${_COLOR_D} $villain $@${_END}"
echo -e "${_COLOR_D}----------------------------------------------------------------------------${_END}\n"
ifPassedArray=() # create an array for checking every required arg is passed-in
argNum=${#shortNameArray[*]}
declare -i i=0
while [ "$argNum" -gt "$i" ]; do
ifPassedArray[$i]="false"
i=$i+1
done
while [ "$#" -gt 0 ]; do
found="false"
declare -i i=0
for short in ${shortNameArray[@]}; do # check if passed-in shortName is valid
if [ "$short" == "$1" ]; then
found="true"
break
fi
i=$i+1
done
if [ "$found" == "true" ]; then # if shortName is valid
validPassedInArgArray[$i]="$1"
ifPassedArray[$i]="true"
if [ "${ifAcceptValueArray[$i]}" == "true" ]; then # check if accepts values
validValues="${validValueArray[$i]}"
if [ -z "$2" ]; then
echo -e "\n${_ERROR}ERROR: the arg [$1] accepts value but passed-in none${_END}"
argUsage 'short'
exit 11
else # check if passed-in value is valid
if [ ! -z "${validValues}" ]; then # if accepts value and has a list of valid value
# iterate all passed-in values, exit on each invalid value
if [ "${ifMultipleArray[$i]}" == "true" ]; then # if can pass-in multi-values
for value_i in $2; do # iterate passed-in values
valid="false"
for value_j in $validValues; do # iterate the list of valid value
if [ "$value_i" == "$value_j" ]; then
valid="true"
break
fi
done
if [ "$valid" == "false" ]; then # passed-in value is invalid
echo -e "\n${_ERROR}ERROR: arg [$1] does not accept value [$value_i]${_END}"
echo -e "${_ERROR}please choose one or more among [${validValues}]${_END}"
echo -e "${_ERROR}multiple values need single or double quotes${_END}"
argUsage 'short'
exit 11
fi
done
else
# iterate all passed-in values, exit on each invalid value
valid="false"
for value in $validValues; do # iterate valid value list
if [ "$value" == "$2" ]; then
valid="true"
break
fi
done
if [ "$valid" == "false" ]; then # passed-in value is invalid
echo -e "\n${_ERROR}ERROR: arg [$1] does not accept value [$2]${_END}"
echo -e "${_ERROR}please choose one among [${validValues}]${_END}"
argUsage 'short'
exit 11
fi
fi
fi
# the condition of [ -z "${validValueArray[$i]}" ] needes no validation
# so all passed-in value(s) should be valid till here, export them by 'eval'
export_cmd="export ${fullNameArray[$i]}=\"$2\"" # make arg can accept values with space, like -x "AA BB"
validPassedInValueArray[$i]="$2"
eval "$export_cmd" # export arg and value to parent script
shift; shift # shift arg and value
fi
else
# simply set the arg to true if not accepts value, only applied to optional arg
export_cmd="export ${fullNameArray[$i]}=true"
validPassedInValueArray[$i]=true
eval "$export_cmd"
shift; # shift only arg
fi
else # if shortName is invalid
echo -e "\n${_ERROR}ERROR: unknown arg [$1]${_END}"
argUsage 'short'
exit 11
fi
done
declare -i i=0
while [ "$argNum" -gt "$i" ]; do
# if not optional but without passing value
if [ "${ifOptionalArray[$i]}" == "false" -a "${ifPassedArray[$i]}" == "false" ]; then
echo -e "\n${_ERROR}ERROR: missing required arg [${shortNameArray[$i]} ${fullNameArray[$i]}]${_END}"
argUsage 'short'
exit 11
fi
i=$i+1
done
}
# add the 1st arg
SetRequestedArg "--help" "true" "HELP_ARG" "displays extended argUsage" "false"
