rob
/
gnscli
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
gnscli/gnscli.sh

2606 lines
80 KiB
Bash
Executable File
Raw Blame History

#!/bin/bash
# add node
# issue with json post data
# rename project
# delete node
# node stop givesjq error
# connect xxx & [opens iterm (or whatever)]
# when oepning new project and caching, "open" the project
# when quitting or changing projects, "close" curproject
# warn if curprojectis closed
VER=0.1
# helper function to turn a directory of scripts into inline
## defaults at the end of this script
function scriptstoinline() {
local outfile files
echo "About to convert scripts from $SCRIPTDIR to inline format:"
files=$(ls -A "${SCRIPTDIR}")
echo "$files" | sed -e 's/^/ - /'
echo
outfile=""
while [[ -z $outfile ]]; do
getstr ":" "./out" "Enter file to place output in"
outfile="$retstr"
if [[ -e $outfile ]]; then
getyn "n" "'$outfile' already exists. Overwrite"
[[ $? -ne 0 ]] && outfile=""
fi
done
cp /dev/null $outfile;
for f in $SCRIPTDIR/*; do
echo -n "Processing ${f}..."
echo "#START_INLINE:$(basename $f)" >> $outfile
cat "$f" >> $outfile
echo "#END_INLINE:$(basename $f)" >> $outfile
echo "done"
done
echo
echo "All done. Replace inline code with the contents of: $outfile"
}
function mkscripts() {
local dir
dir="$1"
info "Creating helper scripts in ${dir}"
cat "$THISSCRIPT" | awk -v dir="$dir" -F: 'BEGIN { curfile=""; } /^#START_INLINE/ { curfile = dir "/" $2; printf(" %s...", curfile) > "/dev/stderr"; } /^#END_INLINE/ { curfile=""; printf("done\n") > "/dev/stderr"; } (curfile != "") { print > curfile; }'
}
function initauth() {
local u p doscripts=0 files
[[ ! -e $CONFDIR ]] && mkdir -p "$CONFDIR" && info "Created $CONFDIR"
[[ ! -e $TMPDIR ]] && mkdir -p "$TMPDIR" && info "Created $CACHEDIR"
[[ ! -e $CACHEDIR ]] && mkdir -p "$CACHEDIR" && info "Created $TMPDIR"
[[ ! -e $SCRIPTDIR ]] && mkdir -p "$SCRIPTDIR" && info "Created $SCRIPTDIR"
[[ ! -e $HISTFILE ]] && cp /dev/null "$HISTFILE" && info "Created $HISTFILE"
# if [[ -e $AUTHFILE ]]; then
# warn "Authentication file $AUTHFILE already exists - skipping creation."
# else
# info "Creating authentication file"
# read -p "Enter gns username: " u
# read -sp "Enter gns password: " p
# echo
# cp /dev/null "${AUTHFILE}"
# [[ $? -ne 0 ]] && error "Can't create $AUTHFILE" && return 1
# echo "$u" >"${AUTHFILE}"
# echo "$p" >>"${AUTHFILE}"
# chmod 600 "$AUTHFILE"
# info "Authentication details stored in $AUTHFILE"
# fi
[[ ! -e $RCFILE ]] && echo "# each line in this file is used as a command-line argument" > "$RCFILE" && info "Created initial $RCFILE"
[[ ! -e $SRVFILE ]] && echo "exampleserver:gns3.example.net:3080" > "$SRVFILE" && info "Created initial $SRVFILE - you need to update this!"
files=$(ls -A "${SCRIPTDIR}")
if [[ -n $files ]]; then
warn "Script directory $SCRIPTDIR already contains files:"
echo -en "$YELLOW"
echo "$files" | sed -e 's/^/ - /'
echo
echo -en "$PLAIN"
getyn n "Overwrite scripts with defaults"
[[ $? -eq 0 ]] && doscripts=1 || doscripts=0
else
doscripts=1
fi
if [[ $doscripts -eq 1 ]]; then
mkscripts "$SCRIPTDIR"
fi
echo -e "$BOLD${CYAN}Initialisation of $BOLD$CONFDIR$PLAIN complete.$PLAIN"
return 0
}
function cache_uuids() { # cache_uuids $$ [locations]
local loc epidx epname api_endpoint curlres mainpid thisfile
local where
mainpid="$1"
shift
if [[ $# -ge 1 ]]; then
where="$*"
else
where="$curlocs"
fi
for loc in $where; do
thisfile="${CACHEFILEBASE}.${loc}"
cp /dev/null "$thisfile"
for epname in ${ep_name[@]}; do
info "- Caching UUID data for $loc $epname"
epidx=$(getepidx $epname)
api_endpoint="${ep_apiendpoint[$epidx]}"
curlres=$(runcurlget $loc $api_endpoint)
[[ $? -ne 0 ]] && error "curl to $thisurl failed" && return 1
echo "$curlres" | jq -r "try (.[] | [ .${ep_idfield[$epidx]}, .name ] | @csv) catch empty" | tr -d '"' >> "$thisfile"
done
done
kill -SIGUSR1 $mainpid
}
function loadcachefile() { # loadcachefile [dc1 dc2 ...]
local f line dc added
if [[ ! -d "$CACHEDIR" ]]; then
return 1
fi
clear_cache
added=0
if [[ $# -ge 1 ]]; then
for dc in $*; do
f=${CACHEFILEBASE}.${dc}
if [[ -e ${f} ]]; then
while read -r line ; do
adduuid "${line%%,*}" "${line##*,}"
if [[ $? -eq 0 ]]; then
added=$((added + 1))
fi
done < "${f}"
fi
done
addmsgq $(info "Loaded $added UUIDs from cache files for $*" 2>&1)
else
ls ${CACHEFILEBASE}.* >/dev/null 2>&1
if [[ $? -eq 0 ]]; then
for f in ${CACHEFILEBASE}.*; do
while read -r line ; do
adduuid ${line%%,*} ${line##*,}
done < "$f"
done
addmsgq $(info "Loaded cache files for all servers" 2>&1)
fi
fi
}
function uuid_callback() {
nuuids=0
loadcachefile $curlocs
uuidend=$(($($GDATE +%s%N)/1000))
uuidsecs=$(echo "scale=2; ($uuidend - $uuidstart) / 1000000;" | bc)
if [[ $nuuids -ge 1 ]]; then
addmsgq $(info "Cached $nuuids UUID(s) for $curlocs in $uuidsecs seconds." 2>&1)
else
addmsgq $(error "No UUIDs found for [$curlocs]" 2>&1)
fi
CACHING=""
trap - SIGUSR1
}
function start_recache_if_needed() {
local dc f needed toload
needed=""
toload=""
for dc in $curlocs; do
f=${CACHEFILEBASE}.${dc}
if [[ -e ${f} ]]; then
toload="$toload $dc"
else
needed="$needed $dc"
fi
done
[[ -n $toload ]] && loadcachefile $toload
[[ -n $needed ]] && start_recache $needed
}
function start_recache() {
local rv
uuidstart=$(($($GDATE +%s%N)/1000))
if [[ -z $recache_pid ]]; then
# setup callback for uuid cache reload handling
trap uuid_callback SIGUSR1
info "Initiating UUID cache refresh for $curlocs..."
CACHING="background task: refreshing cache for $curlocs"
cache_uuids $$ $* &
recache_pid=$!
rv=0
else
rv=1
fi
return $rv
}
# populates global retstr
function getstr() { # getstr last_prompt_char default_answer "prompt string"
local lastchar def prompt rv
lastchar="$1"
shift
def="$1"
shift
prompt="$*"
retstr=""
echo -n -e "${PURPLE}$prompt [$BOLD$def$PLAIN$PURPLE]${lastchar}${PLAIN} "
read retstr
echo -e "$PLAIN"
[[ -z $retstr ]] && retstr="$def"
}
# populates global yn, returns 0 for yes, 1 for no
function getyn() { # getyn default_answer "prompt string"
local def prompt rv
def="$1"
shift
prompt="$*"
yn=""
while [[ $yn != "y" && $yn != "n" ]]; do
getstr "?" "$def" "$prompt"
yn="$retstr"
done
if [[ $yn == "y" ]]; then
rv=0
else
rv=1
fi
return $rv
}
function arraycontains() { # arraycontains arrayname lookfor wildcard
local arr lookfor varname wild lookfor_modified
varname="$1"
lookfor="$2"
shift 2
eval arr=( '"${'${varname}'[@]}"' )
if [[ $# -ge 1 ]]; then
lookfor_modified=" $lookfor"
else
lookfor_modified=" $lookfor "
fi
[[ " ${arr[@]} " =~ $lookfor_modified ]] && return 0
return 1
}
function getcmd() {
local prefix pstr input varname rv
varname=$1
if [[ -z $curproj ]]; then
prefix="[no_project_selected]"
else
prefix="[${curproj}]"
fi
#echo "${BOLD}$prefix rosh> ${PLAIN}"
pstr="$prefix gnscli> "
[[ ! -z $CACHING ]] && info "$CACHING"
set -f
builtin read -p "$(echo -en $BOLD)${pstr}$(echo -e "$PLAIN") " -e -r input
set +f
rv=$?
eval "$varname='$input'"
return $rv
}
function listprojects() {
local x format
format=" %-24s|%-36s${PLAIN}\n"
printf "${UNDERLINE}${BOLD}$format" "Project" "UUID"
for x in ${!proj_name[@]}; do
printf "$format" "${proj_name[$x]}" "${proj_id[$x]}"
done
}
function listservers() {
local x format
format=" %-12s|%-24s|%-34s${PLAIN}\n"
printf "${UNDERLINE}${BOLD}$format" "Location" "Host" "API URL"
for x in ${!loc_name[@]}; do
printf "$format" "${loc_name[$x]}" "${loc_engine[$x]}" "${loc_api[$x]}"
done
}
function profile() {
local fname
fname=${FUNCNAME[2]}
[[ -z $fname ]] && fname=${FUNCNAME[1]}
[[ $PROFILING -eq 1 ]] && echo -e "${YELLOW}${BOLD}${FUNCNAME[1]}(): ${PLAIN}${YELLOW}$*${PLAIN}" 1>&2
}
function debug() {
local force=0
if [[ $1 == "-f" ]]; then
shift
force=1
fi
if [[ $VERBOSE -eq 1 ]]; then
if [[ $force -eq 1 ]]; then
echo -e "${PURPLE}${BOLD}${FUNCNAME[1]}(): ${PLAIN}${PURPLE}$*${PLAIN}" >/dev/stderr
echo -e "${PURPLE}${BOLD}${FUNCNAME[1]}(): ${PLAIN}${PURPLE}$*${PLAIN}" >/tmp/a
else
echo -e "${PURPLE}${BOLD}${FUNCNAME[1]}(): ${PLAIN}${PURPLE}$*${PLAIN}" 1>&2
fi
fi
}
function info() {
echo -e "${CYAN}${ITALIC}[$*]${PLAIN}" 1>&2
}
function error() {
[[ $innotify -eq 1 ]] && fail
echo -e "${RED}${BOLD}ERROR: ${PLAIN}${RED}$*${PLAIN}" 1>&2
}
function notify() {
echo -en "${PURPLE}${BOLD}* ${PLAIN}${PURPLE}$*...${PLAIN} " 1>&2
innotify=1
}
function notify_nodots() {
echo -e "${PURPLE}${BOLD}* ${PLAIN}${PURPLE}$*${PLAIN} " 1>&2
}
function ok() {
local msg=${*:-ok}
[[ $innotify -eq 0 ]] && return 1
echo -e "$GREEN$msg$PLAIN" 1>&2
innotify=0
}
function fail() {
local msg=${*:-failed}
[[ $innotify -eq 0 ]] && return 1
echo -e "$RED$msg$PLAIN" 1>&2
innotify=0
}
function warn() {
echo -e "${YELLOW}${BOLD}Warning: ${PLAIN}${YELLOW}$*${PLAIN}" 1>&2
}
function usage() {
echo "usage: $0 OPTIONS command"
echo
echo " -h Show this text."
echo " -i Generate initial auth file."
echo " -s server Set initial server."
echo " Valid servers: [${loc_name[@]}]"
echo " -p project Set initial project."
echo " -P Profiling mode."
echo " -v Verbose mode."
echo
}
function addcmd() {
local adm
[[ -z $ncmds ]] && ncmds=0
if [[ $1 == "-a" ]]; then
adm=1
shift
else
adm=0
fi
cmd_name[$ncmds]="$1"
cmd_desc[$ncmds]="$2"
cmd_adm[$ncmds]="$adm"
if [[ $3 == ** ]]; then
cmd_minargs[$ncmds]="${3%%+*}"
cmd_maxargs[$ncmds]="99"
cmd_needargs[$ncmds]=">= ${cmd_minargs[$ncmds]}"
elif [[ $3 == *-* ]]; then
cmd_minargs[$ncmds]="${3%%-*}"
cmd_maxargs[$ncmds]="${3##*-}"
cmd_needargs[$ncmds]="${cmd_minargs[$ncmds]}-${cmd_maxargs[$ncmds]}"
else
cmd_minargs[$ncmds]="$3"
cmd_maxargs[$ncmds]="$3"
cmd_needargs[$ncmds]="$3"
fi
shift 3
cmd_aliases[$ncmds]=" $* "
cmd_usage[$ncmds]=""
cmd_optionname[$ncmds]=""
cmd_optiondesc[$ncmds]=""
cmd_maxoptnamelen[$ncmds]=0
ncmds=$((ncmds + 1))
}
function addcmdalias() {
local defarg
[[ -z $ncmdaliases ]] && ncmdaliases=0
cmdalias_src[$ncmdaliases]="$1"
cmdalias_dst[$ncmdaliases]="$2"
defarg="$3"
cmdalias_defaultarg[$ncmdaliases]="$defarg"
ncmdaliases=$((ncmdaliases + 1))
}
function addmsgq() {
msgq[$nmsgq]="$*"
nmsgq=$((nmsgq + 1))
}
function dumpmsgq() {
local x
for x in ${!msgq[@]}; do
echo -e "${msgq[$x]}"
done
msgq=()
nmsgq=0
}
function clear_cache() {
uuid_id=()
uuid_name=()
nuuids=0
}
function adduuid() { # uuid name
# local i
# add
uuid_id[$nuuids]="${1}"
uuid_name[$nuuids]="${2}"
nuuids=$((nuuids + 1))
# i=$(uuid_to_idx "${1}")
# if [[ $? -eq 0 ]]; then
# # update
# uuid_name[$i]="${2}"
# return 1
# else
# # add
# uuid_id[$nuuids]="${1}"
# uuid_name[$nuuids]="${2}"
# nuuids=$((nuuids + 1))
# return 0
# fi
}
function uuid_to_name() {
local x
#for x in ${!uuid_id[@]}; do
# if [[ ${uuid_id[$x]} == $1 ]]; then
# echo "${uuid_name[$x]}"
# return 0
# fi
#done
# faster
for ((x=0; x<${#uuid_id[@]}; ++x)); do
if [[ "${uuid_id[$x]}" == "$1" ]]; then
echo "${uuid_name[$x]}"
return 0
fi
done
echo "$1"
return 1
}
function uuid_to_idx() {
local x
for x in ${!uuid_id[@]}; do
if [[ ${uuid_id[$x]} == $1 ]]; then
echo "${$x}"
return 0
fi
done
return 1
}
function addloc() {
[[ -z $nlocs ]] && nlocs=0
loc_name[$nlocs]="$1"
if [[ $nlocs -eq 0 ]]; then
curlocs="$1"
fi
loc_engine[$nlocs]="$2"
loc_port[$nlocs]="$3"
loc_api[$nlocs]="http://${loc_engine[$nlocs]}:${loc_port[$nlocs]}/v2"
nlocs=$((nlocs + 1))
}
function addproject() {
[[ -z $nprojects ]] && nprojects=0
proj_id[$nprojects]="$1"
proj_name[$nprojects]="$2"
nprojects=$((nprojects + 1))
}
# Don't use '#'. Use ^ for spaces.
function addepfields() { # addepfields ep_name field1 field2 field3 ...
local idx
idx=$(getepidx $1)
if [[ $? -ne 0 ]]; then
error "appepfields(): can't find endpoint named '$1'"
return 1
fi
shift
while [[ $# -ge 1 ]]; do
[[ -z ${ep_fields[$idx]} ]] && ep_fields[$idx]="${1}" || ep_fields[$idx]="${ep_fields[$idx]}#${1}"
shift
done
}
# Don't use '#'. Use ^ for spaces.
function addeptitles() { # addeptitles ep_name title1 title2 title3 ... # Don't use '#' or spaces.
local idx
idx=$(getepidx $1)
if [[ $? -ne 0 ]]; then
error "appeptitles(): can't find endpoint named '$1'"
return 1
fi
shift
while [[ $# -ge 1 ]]; do
ep_titles[$idx]="${ep_titles[$idx]}#${1}"
shift
done
}
function addendpoint() { # addendpoint ep_name ep_apiendpoint ep_jqobjectname ep_idfieldname [defaultfieldname]
[[ -z $neps ]] && neps=0
ep_name[$neps]="$1"
ep_apiendpoint[$neps]="$2"
ep_jqobj[$neps]="$3"
ep_idfield[$neps]="$4"
ep_defaultfield[$neps]="${5:-name}"
ep_alias[$neps]=""
ep_fields[$neps]=""
ep_titles[$neps]="Server"
ep_validactions[$neps]=""
neps=$((neps + 1))
}
function addepalias() { # addeptitles ep_name alias1 alias2 alias3 ...
local idx
idx=$(getepidx $1)
if [[ $? -ne 0 ]]; then
error "appepalias(): can't find endpoint named '$1'"
return 1
fi
shift
while [[ $# -ge 1 ]]; do
ep_alias[$idx]="${ep_alias[$idx]} ${1} "
shift
done
}
function addepactions() { # addepactions ep_name action_name [action_name2] ...
local idx
idx=$(getepidx $1)
if [[ $? -ne 0 ]]; then
error "appepaction(): can't find endpoint named '$1'"
return 1
fi
shift
while [[ $# -ge 1 ]]; do
ep_validactions[$idx]="${ep_validactions[$idx]} ${1} "
shift
done
}
function getcmdidx() { # getcmdidx commandname adminonly(1|0)
local x adm lookfor match
lookfor=$1
adm=$2
match=0
for x in ${!cmd_name[@]}; do
#echo "check alias '${cmd_aliases[$x]}' against '* $lookfor *'" >/dev/stderr
if [[ ${cmd_name[$x]} == $lookfor ]]; then
match=1
elif [[ ${cmd_aliases[$x]} == *\ $lookfor\ * ]]; then
match=1
else
match=0
fi
if [[ $match -eq 1 ]]; then
if [[ -z $adm || ${cmd_adm[$x]} == $adm ]]; then
echo "$x"
return 0
fi
fi
done
return 1
}
function addcmdusage() { # addcmdusage cmd_name "usage goes here" "line 2" "line 3" ...
local cname idx text
cname="$1"
shift
idx=$(getcmdidx $cname)
[[ $? -ne 0 ]] && return 1
text=""
while [[ $# -ge 1 ]]; do
[[ -z $text ]] && text="$1" || text="$text\n$1"
shift 1
done
cmd_usage[$idx]="$text"
}
function addcmdoption() { # addcmdusage cmd_name "usage goes here" "line 2" "line 3" ...
local cname idx text
cname="$1"
shift
idx=$(getcmdidx $cname)
if [[ $? -ne 0 ]]; then
error "Tried to addcmdoption() for nonexistant command '$cname'"
kill $$
fi
while [[ $# -ge 1 ]]; do
[[ -z ${cmd_optionname[$idx]} ]] && cmd_optionname[$idx]="$1" || cmd_optionname[$idx]="${cmd_optionname[$idx]}#$1"
[[ ${#1} -gt ${cmd_maxoptnamelen[$idx]} ]] && cmd_maxoptnamelen[$idx]=${#1}
shift 1
[[ -z ${cmd_optiondesc[$idx]} ]] && cmd_optiondesc[$idx]="$1" || cmd_optiondesc[$idx]="${cmd_optiondesc[$idx]}#$1"
shift 1
done
}
function showcmdhelp() {
local real_cname cname idx text ln x format optname_arr optdesc_arr len
cname="$1"
shift
idx=$(getcmdidx $cname)
if [[ $? -ne 0 ]]; then
error "Invalid command '$cname'"
return 1
fi
real_cname="${cmd_name[$idx]}"
[[ ${cmd_adm[$idx]} -eq 1 ]] && real_cname="\\${real_cname}"
# make array of options
IFS='#' read -r -a optname_arr <<< "${cmd_optionname[$idx]}"
IFS='#' read -r -a optdesc_arr <<< "${cmd_optiondesc[$idx]}"
len=${cmd_maxoptnamelen[$idx]}
echo -n "Usage: ${real_cname} "
[[ $len -gt 0 ]] && echo -n "[OPTIONS] "
# show usage if we have it
if [[ -n ${cmd_usage[$idx]} ]]; then
echo -e "${cmd_usage[$idx]}" | awk '(NR == 1) { print }'
else
echo
fi
echo " ${cmd_desc[$idx]}."
if [[ -n ${cmd_usage[$idx]} ]]; then
echo
echo -e "${cmd_usage[$idx]}" | awk '(NR > 1) { printf(" %s\n",$0); }'
fi
# show options
if [[ $len -gt 0 ]]; then
echo
format=" %-${len}s %s\n"
for x in ${!optname_arr[@]}; do
printf "$format" "${optname_arr[$x]}" "${optdesc_arr[$x]}"
done
fi
# Show aliases
if [[ -n ${cmd_aliases[$idx]// /} ]]; then
echo
echo "Aliases for '${real_cname}': ${cmd_aliases[$idx]}"
fi
echo
}
function getprojidx() { # getprojidx project_name_or_uuid
local x
for x in ${!proj_name[@]}; do
if [[ ${proj_name[$x]} == $1 || ${proj_id[$x]} == $1 ]]; then
echo "$x"
return 0
fi
done
return 1
}
function getlocidx() { # getlocidx <syd|mlb|etc>
local x
for x in ${!loc_name[@]}; do
if [[ ${loc_name[$x]} == $1 ]]; then
echo "$x"
return 0
fi
done
return 1
}
function getlocidx_byregion() { # getlocidx <au|uk|etc>
local x
for x in ${!loc_region[@]}; do
if [[ ${loc_region[$x]} == $1 ]]; then
echo "$x"
return 0
fi
done
return 1
}
function getalllocs() {
echo ${loc_name[@]}
}
function get() { # getloc <syd|mlb|etc> <name|grid|api|etc>
local idx
idx=$(getlocidx $1)
if [[ $? -ne 0 ]]; then
return 1
fi
eval "echo \${loc_${2}[$idx]}"
}
function runcurlget() { # location api_endpoint(ovname)
local thisapi thisurl curlres rv
local thisauthdom u p thisauthstr
local loc api_andpoint
loc="$1"
api_endpoint="$2"
thisapi=$(get $loc api)
[[ -z $thisapi ]] && echo "cant find api for '$loc'" && return 1
thisurl="$thisapi/$api_endpoint"
thisurl=${thisurl/_CURPROJECT_/$curprojid}
debug "url is $thisurl"
#thisauthdom=$(get $loc authdomain)
#u=$(head -1 "$AUTHFILE")
#p=$(tail -1 "$AUTHFILE")
#thisauthstr="$u@$thisauthdom:$p"
#unset u
#unset p
debug "curl -sk --header 'Accept: application/json' $thisurl"
curlres=$(curl -sk --header 'Accept: application/json' $thisurl)
rv=$?
[[ $rv -ne 0 ]] && error "curl to $thisurl failed"
echo "$curlres"
return $rv
}
function runcurldatapost() { # location api_endpoint "curl data"
local thisapi thisurl curlres rv
local loc api_endpoint obname ovmethod
local data=""
loc="$1"
api_endpoint="$2"
data="$3"
thisapi=$(get $loc api)
[[ -z $thisapi ]] && echo "cant find api for '$loc'" && return 1
#thisauthdom=$(get $loc authdomain)
debug -f "data is $data"
thisurl="$thisapi/$api_endpoint"
thisurl=${thisurl/_CURPROJECT_/$curprojid}
debug -f "curl -XPOST -sk --header 'Content-type: application/xml' --header 'Accept: application/json' -d \"$data\" $thisurl"
set -x
curlres=$(curl -XPOST -sk --header 'Content-type: application/xml' --header 'Accept: application/json' -d "$data" $thisurl)
set +x
rv=$?
[[ $rv -ne 0 ]] && error "curl POST to $thisurl failed"
echo "$curlres"
return $rv
}
function runcurlaction() { # location api_endpoint(ovname) obname ovmethod ["curl data"]
local thisapi thisurl curlres rv
#local thisauthdom u p thisauthstr
local loc api_endpoint obname ovmethod
local data=""
#local data="<action/>"
loc="$1"
api_endpoint="$2"
obname="$3"
ovmethod="$4"
data="$5"
thisapi=$(get $loc api)
[[ -z $thisapi ]] && echo "cant find api for '$loc'" && return 1
#thisauthdom=$(get $loc authdomain)
debug -f "data is $data"
thisurl="$thisapi/$api_endpoint/$obname"
[[ -n $ovmethod ]] && thisurl="${thisurl}/$ovmethod"
thisurl=${thisurl/_CURPROJECT_/$curprojid}
#u=$(head -1 "$AUTHFILE")
#p=$(tail -1 "$AUTHFILE")
#thisauthstr="$u@$thisauthdom:$p"
#unset u
#unset p
debug -f "curl -XPOST -sk --header 'Content-type: application/xml' --header 'Accept: application/json' -d \"$data\" $thisurl"
curlres=$(curl -XPOST -sk --header 'Content-type: application/xml' --header 'Accept: application/json' -d "$data" $thisurl)
rv=$?
[[ $rv -ne 0 ]] && error "curl to $thisurl failed"
echo "$curlres"
return $rv
}
# getarrayopt arrname f
#
# ie. if myvar=("aaa" "-z" "-ofirst_test" "123" "-osecond_test"
#
# then "getarrayopt myvar o" will output "first_test"
function getarrayopt() { # getarrayopt arrname optname
local arrname optname arrtext optval rv newarr
local localdb
localdb=0
arrname="$1"
optname="$2"
[[ $localdb -eq 1 ]] && info "look for -$optname in \$$arrname"
# fix in case array indices aren't sequential
arrtext=$(eval "echo \"\${${arrname}[@]}\"")
newarr=( $arrtext )
[[ $localdb -eq 1 ]] && info "arrtext is '$arrtext'"
if arraycontains $arrname "-$optname" WILDCARD; then
local this
# get array index of given option
idx=$(echo "${arrtext}" | awk -v lookfor="-$optname" '{ for (x=1;x<=NF;x++) { if (index($x,lookfor) == 1) print (x-1); } }')
[[ $localdb -eq 1 ]] && info " found at idx $idx"
this=${newarr[$idx]}
optval=${this##*-$optname} # strip "-x" from the start
optval=${optval%% *} # strip all other options from the end
[[ $localdb -eq 1 ]] && info " optval is $optval"
rv=0
else
[[ $localdb -eq 1 ]] && info " not found"
optval=""
rv=1
fi
echo "$optval"
return $rv
}
# convert action name into gns method name
function getgnsmethod() {
local rv=0
case "$1" in
open) echo "open";;
close) echo "close";;
start) echo "start";;
stop) echo "stop";;
add) echo "";;
#migrate) echo "migrate";;
*)
echo
rv=1;
;;
esac
return $rv
}
function makejson() { # makejson key1:val1^key2:val2^...
local plaindata tok toks key val tnum=1
plaindata="$1"
printf "%s" '{'
IFS='^' read -ra toks <<< "$plaindata"
for tok in "${toks[@]}"; do
[[ $tnum -ne 1 ]] && printf "%s" ","
key=${tok%:*}
val=${tok#*:}
printf '"%s":"%s"' "$key" "$val"
tnum=$((tnum + 1))
done
printf "%s\n" '}'
}
function runaction_loc() { # runaction_loc syd|etc api_endpoint action_name ob_uuid ob_name "extra info" [options]
local thisgrid thisauthdom thisurl thisauthstr curlres loc u p
local api_endpoint jq_obj opts opts_arr deffield epidx r1 r2 rv
local actionname method trv extrainfo
local curldata="" crv
rv=0
loc="$1"
epidx="$2"
actionname="$3"
ob="$4"
obname="$5"
extrainfo="$6"
thisgrid=$(get $loc grid)
api_endpoint="${ep_apiendpoint[$epidx]}"
jq_obj="${ep_jqobj[$epidx]}"
deffield="${ep_defaultfield[$epidx]}"
shift 6
opts="$*"
opts_arr=( $opts )
debug -f "extrainfo : $extrainfo"
debug -f "remaining opts: $opts"
if [[ $actionname == "add" ]]; then
curldata=$(makejson "$extrainfo")
fi
# special case
if [[ $actionname == "connect" ]]; then
local locidx
# todo: only a single curloc, not multiple
locidx=$(getlocidx $curlocs)
if [[ $? -ne 0 ]]; then
error "Couldn't determine index of current location '$curlocs'"
return 1
fi
tmux ls 2>&1 | egrep -q "^$curproj:"
if [[ $? -eq 0 ]]; then
debug "using existing tmux session with: tmux neww -S -n $obname telnet ${loc_engine[$locidx]} ${extrainfo}"
# create or attach to window
tmux neww -S -n $obname telnet ${loc_engine[$locidx]} ${extrainfo}
trv=$?
else
debug "making new tmux session with: tmux new -s gnscli -n $obname -d telnet ${loc_engine[$locidx]} ${extrainfo}"
# create a new session and window
tmux new -s $curproj -n $obname -d telnet ${loc_engine[$locidx]} ${extrainfo}
trv=$?
fi
if [[ $trv -eq 0 ]]; then
tmux a -t $curproj
else
error "tmux call failed"
return 1
fi
else
method=$(getgnsmethod "$actionname")
if [[ $? -ne 0 ]] ; then
error "Can't determine gns API method for command '$action'"
return 1
fi
debug -f "location: ${loc}"
debug -f "api endpoint: ${api_endpoint}"
debug -f "jq obj: ${jq_obj}"
debug -f "actionname: ${actionname} (gns method: '$method')"
debug -f "obname: ${ob}"
debug -f "options: ${opts}"
debug -f "curldata: ${curldata}"
if [[ $action == "add" ]]; then
curlres=$(runcurldatapost $loc $api_endpoint "$curldata" )
crv=$?
else
curlres=$(runcurlaction $loc $api_endpoint $ob $method "$curldata" )
crv=$?
fi
if [[ $crv -ne 0 ]]; then
rv=1
fi
debug -f "curlres is [$curlres]"
echo "$curlres"
fi
return $rv
}
function getdata_loc() { # getdata_loc syd|etc api_endpoint [options]
local thisgrid thisauthdom thisurl thisauthstr curlres loc u p
local api_endpoint jq_obj opts opts_arr deffield epidx r1 r2 rv
rv=0
loc="$1"
epidx="$2"
thisgrid=$(get $loc grid)
api_endpoint="${ep_apiendpoint[$epidx]}"
jq_obj="${ep_jqobj[$epidx]}"
deffield="${ep_defaultfield[$epidx]}"
shift 2
opts="$*"
opts_arr=( $opts )
debug "options: ${opts}"
curlres=$(runcurlget $loc $api_endpoint)
[[ $? -ne 0 ]] && error "curl to $loc API failed" && return 1
debug "outmode is $outmode"
if [[ $outmode == "raw" ]]; then
[[ ! -z $curlres ]] && echo "$curlres" || rv=2
elif [[ $outmode == "verbose" ]]; then
#if [[ $locnum -eq 1 ]]; then
# # bold+underline the heading, and store in a temp file
# echo "$curlres" | jq -r "$jqfilter" 2>/dev/null | tr -d '"' | awk '{ if (NR == 1) { printf "\033[1m\033[4m" $0 "\033[0m\n" } }' >$HEADINGFILE
#fi
debug "jqfilter is $jqfilter"
debug "r1 pre jqfilter is $curlres"
r1=$(echo "$curlres" | jq -r "$jqfilter" 2>/dev/null | tr -d '"')
debug "r1 post jqfilter is $r1"
#if [[ ! -z $regexpfilter ]]; then
# [[ $VERBOSE -eq 1 ]] && debug "r1 pre regexpfilter is $r1"
# r1=$(echo "$r1" | awk -v filter="$regexpfilter" '(NR==1){ print } (NR !=1 && (match($0,filter))) { print }')
#fi
[[ ! -z $r1 ]] && echo "$r1" || rv=2
else # namesonly
r1=$(echo "$curlres")
echo "$r1" >/tmp/out
if [[ ! -z $jqfilter ]]; then
debug "jqfilter is $jqfilter"
debug "r1 pre jqfilter is $r1"
r1=$(echo "$r1" | jq -r "$jqfilter" 2>/dev/null)
debug "r1 post jqfilter is $r1"
fi
if [[ ! -z $jqscript ]]; then
debug "jqscript is $jqscript"
debug "r1 pre jqscript is $r1"
r1=$(echo "$r1" | jq -rf "$jqscript")
fi
# if [[ ! -z $regexpfilter ]]; then
# debug "r1 pre regexpfilter is $r1"
# r1=$(echo "$r1" | awk -v filter="$regexpfilter" '(NR==1){ print } (NR !=1 && (match($0,filter))) { print }')
# fi
if [[ ! -z $awkscript ]]; then
debug "r1 pre awkscript is $r1"
r1=$(echo "$r1" | awk -f "$awkscript")
fi
debug "semi-final r1 is [$r1]"
if [[ $cmd == "list" ]]; then
debug "Global cmd is $GLOBALCMD"
if [[ $GLOBALCMD == "action" ]]; then
# ie. we end up with each line being:
# location,object,object_uuid
#r1=$(echo "$r1" | egrep -v "^$" | sed "s/^/$loc,$thisgrid,/")
r1=$(echo "$r1" | egrep -v "^$" | sed "s/^/$loc,/")
else
#r1=$(echo "$r1" | egrep -v "^$" | sed "s/^/$(echo -e "$BOLD")\[$thisgrid\] $(echo -e "$PLAIN")/")
r1=$(echo "$r1" | egrep -v "^$")
fi
fi
debug "final r1 is [$r1]"
[[ -n $r1 ]] && echo "$r1" | sed 's/__END__://' || rv=2
fi
#echo "$curlres" | jq -r "$jqfilter" | sed "s/^/$(echo -e "$BOLD")\[$thisgrid\] $(echo -e "$PLAIN")/"
debug "about to exit with code $rv"
return $rv
}
function getlocidx() { # getlocidx locname
local x lookfor
lookfor="$1"
for x in ${!loc_name[@]}; do
if [[ ${loc_name[$x]} == $lookfor ]]; then
echo "$x"
return 0
fi
done
return 1
}
function getepidx() { # getepidx epname
local x lookfor
lookfor="$1"
for x in ${!ep_name[@]}; do
if [[ ${ep_name[$x]} == $lookfor || ${ep_alias[$x]} == *\ $lookfor\ * ]]; then
echo "$x"
return 0
elif [[ ${ep_name[$x]} == ${lookfor}s || ${ep_alias[$x]} == *\ ${lookfor}s\ * ]]; then
echo "$x"
return 0
fi
done
return 1
}
function getepjqobj() {
local x
for x in ${!ep_name[@]}; do
if [[ ${ep_name[$x]} == $1 || ${ep_alias[$x]} == *\ $1\ * ]]; then
echo "${ep_jqobj[$x]}"
return 0
fi
done
return 1
}
function getepovname() {
local x
for x in ${!ep_name[@]}; do
if [[ ${ep_name[$x]} == $1 || ${ep_alias[$x]} == *\ $1\ * ]]; then
echo "${ep_apiendpoint[$x]}"
return 0
fi
done
return 1
}
function getbasefilter() { # epidx [regexp_filter]
local bf x first epidx local refilter defaultvalue="unknown" thisdefault
local filterarg
epidx="$1"
shift
filterarg="$*"
[[ $filterarg == "*" ]] && filterarg=".*"
[[ -n "$*" ]] && refilter="select(.name|test(\"^$*$\"))" || refilter="."
IFS='#' read -r -a titles <<< "${ep_titles[$epidx]}"
IFS='#' read -r -a fields <<< "${ep_fields[$epidx]}"
bf=""
for x in ${titles[@]}; do
x=${x//^/ }
[[ -z $bf ]] && bf="([" || bf="$bf, "
bf="${bf}\"${x}\""
done
#bf="${bf}] ), (.$jq_obj[] | $refilter | [\"_LOCATION_\""
bf="${bf}] ), (.[] | $refilter | [\"_LOCATION_\""
first=1
for x in ${fields[@]}; do
thisdefault="defaultvalue"
[[ $x == ".status" ]] && thisdefault="project_closed"
x=${x//^/ }
#bf="${bf}, try(${x}) catch(\"xx\")"
bf="${bf}, ${x} // \"${thisdefault}\""
done
bf="${bf}]) | @csv"
echo "${bf}"
}
function profile_start() {
profile "start profiling"
prof_start=$(($($GDATE +%s%N)/1000))
prof_last="$prof_start"
}
function profile_mark() {
local now secs
now=$(($($GDATE +%s%N)/1000))
secs=$(echo "scale=2; ($now - $prof_last) / 1000000;" | bc)
profile "[+${secs} secs] $* "
prof_last="$now"
}
# Output CSV contents as a nicely formatted table.
# If a heading row is detected, it is bolded and underlines.
# The last table line is also underlined.
# A blank line is printed before each change of first column value - this is generally the data centre name.
function csv_to_table() { # csv_to_table num_data_lines_excluding_heading "csv_string_with_newlines"
local ndatalines msg
local table
local data ln
local uuidcolumn uuidcolumns thisuuid repl line
local col colidx
profile_start
ndatalines="$1"
shift 1
msg="$*"
# table=$(echo -e "$msg" | column -t -s, | awk -v ndatalines=$ndatalines '{ if (match($0, "DC|TOTAL") == 1) { hdgline=1; } else { hdgline=0 } if (!hdgline && pfw != "" && $1 != pfw) { print " " } if (NR == 1 ) { printf "\033[1m\033[4m" $0 "\033[0m\n" } else if (NR == ndatalines ) { printf "\033[4m" $0 "\033[0m\n"} else if (!hdgline || index($0,"TOTAL") == 1) { print } if (!hdgline) { pfw=$1; } }')
table=$(echo -e "$msg" | column -t -s, | awk -v ndatalines=$ndatalines 'BEGIN { max=0 } { if (length($0) > max) max=length($0); } { if (match($0, "Server|TOTAL") == 1) { hdgline=1; } else { hdgline=0 } if (!hdgline && pfw != "" && $1 != pfw) { print " " } if (NR == 1 ) { printf "\033[1m\033[4m" $0 "\033[0m\n" } else if (NR == ndatalines) { print; for (n=0;n<max;n++) printf("-"); printf("\n"); } else if (!hdgline || index($0,"TOTAL") == 1) { print } if (!hdgline) { pfw=$1; } }')
profile_mark "made initial table"
# Find out which columns need a UUID lookup
if [[ $usecache -eq 1 ]]; then
uuidcolumns=$(csv_find_uuid_cols "$msg")
table=${table//_UUID/ }
else
uuidcolumns=""
fi
profile_mark "found uuid columns"
# At this point, $table is the full table table without UUID replacement
ln=1
table2=""
while read -r line ; do
if [[ $ln -gt 1 ]]; then
# Replace UUIDS with names from cache
for uuidcolumn in $uuidcolumns; do
uuidcolumn=$((uuidcolumn - 1))
#if [[ $ln -eq $ndatalines ]]; then
# # Account for underline ANSI code
# uuidcolumn=$(( $uuidcolumn + $UNDERLINE_LENGTH))
#fi
thisuuid=${line:${uuidcolumn}:${UUIDLENGTH}}
debug "uuidcol $uuidcolumn: thisuuid is [$thisuuid]"
repl=$( printf "%-${UUIDLENGTH}s" "$(uuid_to_name $thisuuid)")
debug "repl is $repl"
[[ -n $repl ]] && line="${line/${thisuuid}/$repl}"
done
fi
table2="${table2}${line}\n"
ln=$((ln + 1))
done <<< "$table"
profile_mark "replaced uuids with names"
# save RAM in case of super big data
unset table
profile_mark "created colourisation sed script"
table2=$(echo "$table2" | gsed "$ADD_COLOURS")
echo -e "$table2"
profile_mark "added colours"
}
# Process the first line of CSV contents and try to figure out which
# columnds contain an object UUID based on the heading.
function csv_find_uuid_cols() {
echo "$*" | column -t -s, | egrep "^(Server)" | head -1 | awk 'BEGIN {start=1} { idx=1; while (idx>0) { idx=match(substr($0,start), "[a-zA-Z-]+_UUID"); if (idx>0) { uuidcols = uuidcols " " start+idx-1; start+=(idx+RLENGTH); } } } END { print uuidcols }'
}
function runaction() { # runaction <nodes|vms|etc> <actionname> targetlist options
local targetlist
local loc ob obuuid what api_endpoint jq_obj
local start end opts opts_a
local x epidx
local actionname line all
local force=0 foreground=0 f rv files n thisfile jqres goterror
local good allgoodresults errs allbadresults
local jqf='[ "_DC_", .job.id, "_OB_", .status ] | @csv'
local jqf_bad='[ "_DC_", "_OB_", .fault.detail, .fault.reason, .status ] | @csv'
local objecttype extrainfo
start=$(($($GDATE +%s%N)/1000))
lastqsecs=""
lastprocsecs=""
what="$1"
shift
actionname="$1"
shift
targetlist="$1"
shift
opts="$*"
opts_a=( $* )
epidx=$(getepidx $what)
[[ $? -ne 0 ]] && error "unknown endpoint '$what'" && return 1
jq_obj="${ep_jqobj[$epidx]}"
api_endpoint="${ep_apiendpoint[$epidx]}"
[[ -z $api_endpoint ]] && error "no endpointname for endpoint '$what'" && return 1
debug "what = $what"
debug "actionname = $actionname"
debug "targetlist = $targetlist"
debug "opts is $opts"
arraycontains opts_a "-f" && force=1 || force=0
arraycontains opts_a "-F" && foreground=1 || foreground=0
if [[ $foreground -eq 1 ]]; then
# just use one line
line=$(echo "$targetlist" | head -1)
loc=$(echo "$line" | cut -d, -f1)
ob=$(echo "$line" | cut -d, -f2)
obuuid=$(echo "$line" | cut -d, -f3)
extrainfo="$(echo "$line" | cut -d, -f4-)"
runaction_loc $loc $epidx $actionname $obuuid $ob "$extrainfo" $opts > "$TMPDIR/run,$loc,$ob"
else
pids=""
while read -r line ; do
loc=$(echo "$line" | cut -d, -f1)
ob=$(echo "$line" | cut -d, -f2)
obuuid=$(echo "$line" | cut -d, -f3)
extrainfo=$(echo "$line" | cut -d, -f4-)
debug "extrainfo is: $extrainfo"
runaction_loc $loc $epidx $actionname $obuuid $ob "$extrainfo" $opts > "$TMPDIR/run,$loc,$ob" &
pids="$pids $!"
done <<< "$targetlist"
wait $pids
files=( $TMPDIR/run,* )
unset ACTIONRES_LOC
unset ACTIONRES_MSG
n=0
errs=0
good=0
rv=0
# Capitalise first letter
objecttype=$(echo ${what:0:1} | tr '[a-z]' '[A-Z]')${what:1}
allgoodresults="Server,${objecttype},Job Status"
allbadresults=""
for f in ${!files[@]} ; do
local thiscsv
thisfile="${files[$f]}"
debug "processing file $thisfile"
debug "contents: $(cat $thisfile)"
ACTIONRES_LOC[$n]=$(echo "$thisfile" | cut -d, -f2)
ACTIONRES_OB[$n]=$(echo "$thisfile" | cut -d, -f3)
jqres=$(cat ${thisfile} | jq . 2>/dev/null)
if [[ $? -eq 0 ]]; then
ACTIONRES_MSG[$n]="$jqres"
else
ACTIONRES_MSG[$n]=$(cat ${thisfile})
fi
if [[ ${ACTIONRES_MSG[$n]} == *detail*reason* ]]; then
goterror=1
elif [[ ${ACTIONRES_MSG[$n]} == *rror* ]]; then
goterror=1
elif [[ ${ACTIONRES_MSG[$n]} == *message* ]]; then
goterror=1
else
goterror=0
fi
if [[ $goterror -eq 1 ]]; then
#thiscsv_bad=$(echo "${ACTIONRES_MSG[$n]}" | jq -r "${jqf_bad}" | sed -e "s/_DC_/${ACTIONRES_LOC[$n]}/g" | sed -e "s/_OB_/${ACTIONRES_OB[$n]}/" | tr -d '"[]' | egrep -v "^$")
thiscsv_bad=$(echo "${ACTIONRES_MSG[$n]}" | jq -r . | sed -e "s/_DC_/${ACTIONRES_LOC[$n]}/g" | sed -e "s/_OB_/${ACTIONRES_OB[$n]}/" | egrep -v "^$")
allbadresults="${allbadresults}\n${thiscsv_bad}"
errs=$((errs + 1))
else
thiscsv=$(echo "${ACTIONRES_MSG[$n]}" | jq -r "${jqf}" | sed -e "s/_DC_/${ACTIONRES_LOC[$n]}/g" | sed -e "s/_OB_/${ACTIONRES_OB[$n]}/" | tr -d '"' | egrep -v "^$")
allgoodresults="${allgoodresults}\n${thiscsv}"
good=$((good + 1))
#echo -e "$GREEN" >/dev/stderr
fi
n=$((n + 1))
done
echo
if [[ $errs -gt 0 ]]; then
local fullres_bad
echo -e "${RED}$errs x '${BOLD}$actionname${PLAIN}${RED}' actions failed:${PLAIN}"
echo -e "${RED}"
echo "$allbadresults" | sed -e 's/^/ /'
echo -e "${PLAIN}"
echo
fi
if [[ $good -ge 1 ]]; then
local fullres
echo -e "${GREEN}$good x '${BOLD}$actionname${PLAIN}${GREEN}' actions submitted successfully.${PLAIN}"
fullres=$(csv_to_table $(($good + 1)) "$allgoodresults")
echo "$fullres"
fi
if [[ $good -ge 1 ]]; then
rv=0
else
rv=1
fi
rm -f $TMPDIR/run,*
fi
end=$(($($GDATE +%s%N)/1000))
lastqsecs=$(echo "scale=2; ($end - $start) / 1000000;" | bc)
return $rv
}
function validate_action() { # nodes/vms/etv actionname
local what acion epidx
what="$1"
action="$2"
epidx=$(getepidx $what)
[[ $? -ne 0 ]] && return 1
[[ ${ep_validactions[$epidx]} != *\ $action\ * ]] && return 1
return 0
}
function getdata() { # getdata <nodes|vms|etc> <cmd> options
local loc what api_endpoint jq_obj
local start end opts opts_a parallel
local idx thisopt outfile datawithheading bf
local basefilter outmode bitswewant x epidx titles fields
local heading cols wantcols
local cmd fullres line everything uuidcols ln
local usecache refilter
local w greenwords yellowwords redwords uuidcol
local errordebug=0
local quiet=0 ignorecase=0
start=$(($($GDATE +%s%N)/1000))
lastqsecs=""
lastprocsecs=""
what="$1"
shift
cmd="$1"
shift
set -f
opts="$*"
opts_a=( $* )
set +f
epidx=$(getepidx $what)
[[ $? -ne 0 ]] && error "unknown endpoint '$what'" && return 1
jq_obj="${ep_jqobj[$epidx]}"
api_endpoint="${ep_apiendpoint[$epidx]}"
[[ -z $api_endpoint ]] && error "no endpointname for endpoint '$what'" && return 1
#outmode=namesonly # global
if [[ $cmd == "show" ]]; then
outmode=namesonly # global
else
outmode=verbose # global
fi
arraycontains opts_a "-r" && outmode=raw
arraycontains opts_a "-q" && quiet=1
arraycontains opts_a "-v" && outmode=verbose
arraycontains opts_a "-s" && outmode=namesonly
arraycontains opts_a "-c" && ignorecase=1
arraycontains opts_a "-n" && usecache=0 || usecache=1
arraycontains opts_a "-e" && errordebug=1
debug "opts is $opts"
outfile=$(getarrayopt opts_a o)
refilter=$(getarrayopt opts_a f)
[[ $refilter == "*" ]] && refilter=".*"
if [[ -n $refilter ]]; then
obfilter="select(.name|test(\"^$refilter$\""
if [[ $ignorecase -eq 1 ]]; then
obfilter="${obfilter}; \"i\"))"
else
obfilter="${obfilter}))"
fi
else
obfilter="."
fi
[[ -n $refilter ]] && [[ $quiet -eq 0 ]] && info "${what} filter: ^$refilter$"
# Allow standard globs rather than regexp globs
debug "refilter is $refilter"
# determine jq filter based on object name
jqfilter=""
jqscript=""
awkscript=""
if [[ $cmd == "list" ]]; then
if [[ $outmode == "verbose" ]]; then
if [[ -z ${ep_fields[$epidx]} ]]; then
error "Verbose mode not supported for the '$api_endpoint' endpoint"
return 1
else
#bitswewant=" [ .name, .address, .status, .spm.status ]"
basefilter=$(getbasefilter $epidx "$refilter")
#basefilter="([\"DC\", \"Node \",\"IP \",\"Status\",\"SPM\"] ), (.$jq_obj[] | [\"_LOCATION_\", .name, .address, .status, .spm.status]) | @csv"
fi
elif [[ $outmode == "namesonly" ]]; then
basefilter=".[] | $obfilter | .${ep_defaultfield[$epidx]}"
debug "(list) basefilter is $basefilter"
if [[ $GLOBALCMD == "action" ]]; then
basefilter="${basefilter} + \",\" + .${ep_idfield[$epidx]}"
if [[ ${ep_name[$epidx]} == "nodes" ]]; then
basefilter="${basefilter} + \",\" + (.console|tostring)"
fi
fi
fi
elif [[ $cmd == "show" ]]; then
if [[ $outmode == "verbose" ]]; then
error "Verbose mode not supported for show command yet"
return 1
else # namesonly
#basefilter=".$jq_obj[] | select(.name|test(\"${arg_array[1]}\"))"
basefilter=".[] | $obfilter"
#basefilter=".[]"
jqscript="$SCRIPTDIR/${jq_obj}.jq"
awkscript="$SCRIPTDIR/detail.awk"
debug "jqscript is $jqscript"
debug "awkscript is $awkscript"
if [[ ! -z $jqscript && ! -e $jqscript ]]; then
error "'show' not yet implemented for object type '$jq_obj'"
return 1
fi
fi
fi
locnum=1
if [[ -z $outfile ]]; then
pids=""
notify "Obtaining data from gns API"
for loc in $curlocs; do
[[ ! -z $basefilter ]] && jqfilter=${basefilter/_LOCATION_/${loc}}
[[ $VERBOSE -eq 1 ]] && debug "jqfilter is $jqfilter"
[[ $VERBOSE -eq 1 ]] && debug "jqscript is $jqscript"
[[ $VERBOSE -eq 1 ]] && debug "awkscript is $awkscript"
#echo "jqfilter is:" >/dev/stderr
#echo "$jqfilter" >/dev/stderr
debug " starting getdata $loc $epidx $opts"
getdata_loc $loc $epidx $opts > "$TMPDIR/get.$loc" 2>"$TMPDIR/err.$loc" &
pids="$pids $!"
locnum=$((locnum + 1))
done
wait $pids
debug all pids finished
all=$(cat "$TMPDIR"/get.* 2>/dev/null | tr -d : | egrep -v 'DC|Server' | sed '/^[[:space:]]*$/d')
if [[ -z $all ]]; then
fail
cat "$TMPDIR"/err.*
rm -f "$TMPDIR"/get.*
rm -f "$TMPDIR"/err.*
return 1
fi
ok
if [[ $errordebug -eq 1 ]]; then
if [[ $( ls "$TMPDIR"/err.* | wc -l | bc) -gt 0 ]]; then
cat "$TMPDIR"/err.* >/dev/stderr
fi
fi
debug "combined results: [$all]"
end=$(($($GDATE +%s%N)/1000))
lastqsecs=$(echo "scale=2; ($end - $start) / 1000000;" | bc)
start=$(($($GDATE +%s%N)/1000))
rescount=$(printf %d $(echo -n "$all" | wc -c))
if [[ $rescount -eq 0 ]]; then
echo -e " ${BOLD}${YELLOW}(no results)${PLAIN}"
echo
rm -f $TMPDIR/get.*
rm -f $TMPDIR/err.*
elif [[ $outmode == "verbose" && $cmd == "list" ]]; then
# totals
# get col numbers which we need to total
heading=$(cat $TMPDIR/get.* | head -1 | tr ',' ' ')
debug "heading is [$heading]"
cols=( $heading )
wantcols=""
for x in ${!cols[@]}; do
debug " checking ${cols[$x]}"
if [[ ${cols[$x]} =~ CPUs|RAM|VMs ]]; then
wantcols="$wantcols,$((x + 1))"
fi
done
debug "wantcols is [$wantcols]"
if [[ ! -z $wantcols ]]; then
wantcols="$wantcols,"
# generate totals line
cat $TMPDIR/get.* | column -t -s, | awk -vCOLS="${wantcols}" '{ gsub(" GB", "_GB"); if (index($0,"Server") == 1 && maxf == "") { maxf = NF } else { split(COLS, c, ","); for (x in c) { if (c[x]) { this = $(c[x]); rv=gsub("_GB","",this); if (rv!=0) { isgb[c[x]]=1; } tot[c[x]] += this; } } } gsub("_GB"," GB"); } END { line=""; for (i=1; i<=maxf; i++) { if (i==1) { str="TOTAL:"} else if (index(COLS, "," i ",")) { str = tot[i]; } else { str=" "} line = line sprintf("%s%s,",str, isgb[i] ? " GB" : ""); } printf("%s\n",line); }' > "$TOTFILE"
ndatalines=$(printf %d $(cat $TMPDIR/get.* | wc -l))
else
cp /dev/null "$TOTFILE"
ndatalines=-1
fi
# print combined data (with only one heading row) and totals
#everything=$(cat $TMPDIR/get.* "$TOTFILE" | column -t -s,)
everything=$(cat $TMPDIR/get.* "$TOTFILE")
notify "Processing data"
fullres=$(csv_to_table $ndatalines "$everything")
ok && echo 1>&2
echo "$fullres"
debug "fullres is: [$fullres]"
rm -f $TOTFILE
else
# ie. show
fullres=$(cat $TMPDIR/get.*)
if [[ $outmode == "raw" ]]; then
echo "$fullres"
else
local updated_result
# Replace UUIDS with names from cache
# and colourise certain words
greenwords="true up enabled"
redwords="false down paused uninitialized disabled"
yellowwords="migrating"
uuidcol="$PURPLE"
updated_result=""
while read -r line ; do
key=${line%%:*}
val=${line##*:}
val=$(echo "$val" | sed -e 's/^.* //')
if [[ $key =~ [A-Za-z]+\ UUID ]]; then
repl="$(uuid_to_name ${val})"
if [[ $? -eq 0 ]]; then
line="${line/${val}/$repl} (${uuidcol}${val}${PLAIN})"
else
line="${line/$val/${uuidcol}${val}${PLAIN}}"
fi
#if [[ -n $repl ]]; then
# #line=$(echo "${line}" | sed -e 's/[A-Za-z]\+ UUID/UUID/')
# line="${line/${val}/$repl}"
#fi
elif [[ $key =~ UUID ]]; then
# colourise the entire key
line="${line/${val}/${uuidcol}${val}$PLAIN}"
fi
updated_result="${updated_result}${line}\n"
done <<< "$fullres"
fi
#cat $TMPDIR/get.*
fi
updated_result=$(echo "$updated_result" | gsed "$ADD_COLOURS")
echo -e "$updated_result"
rm -f $TMPDIR/get.*
else
# serial
cp /dev/null "$outfile"
notify "Obtaining data from gns API into file"
for loc in $curlocs; do
jqfilter=${basefilter/_LOCATION_/${loc}}
getdata_loc $loc $epidx $opts >> "$outfile"
locnum=$((locnum + 1))
done
if [[ $errordebug -eq 1 ]]; then
if [[ $( ls "$TMPDIR"/err.* | wc -l | bc) -gt 0 ]]; then
cat "$TMPDIR"/err.* >/dev/stderr
fi
fi
ok
#if [[ -e ${HEADINGFILE} ]]; then
# datawithheading=$(cat ${HEADINGFILE} ${outfile})
# echo "${datawithheading}" > "$outfile"
# rm -f $HEADINGFILE
#fi
info $(printf "%d line(s) written to %s" $(cat "$outfile" | wc -l) "$outfile" )
fi
#end=$(($(gdate +%s%N)/1000))
#lastqsecs=$(echo "scale=2; ($end - $start) / 1000000;" | bc)
end=$(($($GDATE +%s%N)/1000))
lastprocsecs=$(echo "scale=2; ($end - $start) / 1000000;" | bc)
}
function listcommands() {
local x wantadm
if [[ $1 == "ADMIN" ]]; then
wantadm=1
prefix='\'
else
wantadm=0
prefix=""
fi
for x in ${!cmd_name[@]}; do
if [[ ${cmd_adm[$x]} -eq $wantadm ]]; then
printf " %-10s %s\n" "${prefix}${cmd_name[$x]}" "${cmd_desc[$x]}"
if [[ $wantadm -eq 0 && ${cmd_name[$x]} == "help" ]]; then
# show that there is admin help available
printf " %-10s %s\n" "\\help" "List admin commands."
fi
fi
done
}
function generate_random_string() {
local segmentlen=5 x str="" thissegment
for x in {1..5}; do
thissegment=$(LC_CTYPE=C tr -dc a-z0-9 < /dev/urandom | fold -w ${segmentlen} | head -n 1)
[[ -n $str ]] && str="${str} "
str="${str}${thissegment}"
done
echo "$str"
}
function expand_cmdalias() { # expand_cmdalias "cmd" newcmd_var newargs_var "args"
local origcmd newcmd x firstword rest defarg changed=0 args
local newarg_varname newargs
local newcmd_varname
local repl_cmd repl_args
origcmd="$1"
shift
newcmd_varname="$1"
shift
newarg_varname="$1"
shift
args="$*"
newargs="$args" # default
newcmd="$origcmd" # default
for x in ${!cmdalias_src[@]} ; do
if [[ ${cmdalias_src[$x]} == $origcmd ]]; then
debug " matched"
# Matched
# cmd is FIRST WORD of _dst. rest goes before args.
repl_cmd="${cmdalias_dst[$x]%% *}"
repl_args="${cmdalias_dst[$x]#* }"
newcmd="$repl_cmd"
if [[ -n $args ]]; then
newargs="$repl_args $args"
else
debug "using default arg $defarg"
defarg=${cmdalias_defaultarg[$x]}
defarg=${defarg/_CURPROJECT_/$curproj}
debug " default arg is: [$defarg]"
newargs="$repl_args $defarg"
fi
changed=1
break
fi
done
eval "$newcmd_varname=\"$newcmd\""
eval "$newarg_varname=\"$newargs\""
if [[ $changed -eq 1 ]]; then
debug "expanded [$origcmd] to [$cmd], args is [$newargs]"
return 0
fi
return 1
}
function processcmd() {
local cmd arg newarg rv newlocs x err admin idx opts pipe gotargs
local whattolist actionname="" actionfilter=""
local showerror=0 showerroropt=""
local epidx endpoint newname newtype newtype_uuid
cmd=$1
shift
arg="$*"
shift
[[ -z ${cmd:0:1} ]] && return 0
[[ ${cmd:0:1} == "#" ]] && return 0
if [[ ${cmd:0:1} == \\ ]]; then
cmd=${cmd:1}
admin=1
else
admin=0
fi
idx=$(getcmdidx "$cmd" $admin)
rv=$?
if [[ $rv -ne 0 ]]; then
# check aliases
debug "pre replacedargs is [$args]"
expand_cmdalias "$cmd" replacedcmd replacedargs "$arg"
debug "post replacedargs is [$replacedargs]"
cmd="$replacedcmd"
arg="$replacedargs"
idx=$(getcmdidx "$cmd" $admin)
rv=$?
fi
if [[ $rv -ne 0 ]]; then
if [[ $admin -eq 1 ]]; then
error "Invalid admin command '\\$cmd'"
else
error "Invalid command '$cmd'"
fi
return 1
fi
# replace command aliases with base command name
cmd=${cmd_name[$idx]}
GLOBALCMD="$cmd"
# strip pipe suffix
if [[ $arg == *\|* ]]; then
pipe=${arg#*|}
arg=${arg%%|*}
else
pipe="cat"
fi
# strip options from arguments
declare -a opts
newarg=""
for x in $arg; do
if [[ ${x:0:1} == - ]]; then
opts+=($x)
else
[[ -z $newarg ]] && newarg="$x" || newarg="$newarg $x"
fi
done
arg="$newarg"
arg_array=( $arg )
if arraycontains opts "-h"; then
showcmdhelp "$cmd"
return 0
fi
if arraycontains opts "-e"; then
showerror=1
showerroropt="-e"
fi
gotargs=$( printf %d $(wc -w <<< "$arg"))
if [[ $gotargs -lt ${cmd_minargs[$idx]} || $gotargs -gt ${cmd_maxargs[$idx]} ]]; then
error "${cmd_name[$idx]} requires ${cmd_needargs[$idx]} arguments (got $gotargs)"
return 1
fi
obname="" # global
if [[ $cmd == "show" ]]; then
endpoint=${arg_array[0]} && unset 'arg_array[0]'
whattolist=${endpoint}
[[ ${#arg_array[@]} -ge 1 ]] && opts+=("-f${arg_array[@]}")
elif [[ $cmd == "list" ]]; then
endpoint=${arg_array[0]} && unset 'arg_array[0]'
whattolist=${endpoint}
[[ ${#arg_array[@]} -ge 1 ]] && opts+=("-f${arg_array[@]}")
elif [[ $cmd == "action" ]]; then
endpoint=${arg_array[0]} && unset 'arg_array[0]'
whattolist=${endpoint}
actionname=${arg_array[1]} && unset 'arg_array[1]'
if [[ $actionname == "add" ]]; then
newname=${arg_array[2]}
if [[ -z $newname ]]; then
error "Name of new $whattolist not provided."
return 1
fi
# ie. look for models named 'IOS'
# oooo ...if we find one, check its template_type
# if it's qemu then use template_id to figure out appliance id???
# otherwise just use template_type
whattolist="model"
newtype=".*${arg_array[3]}.*"
actionfilter="-f${newtype}"
else
# start/stop/etc
if [[ ${#arg_array[@]} -ge 1 ]]; then
actionfilter="-f${arg_array[@]}"
obname="${arg_array[@]}"
else
error "Name of $whattolist not provided."
return 1
fi
fi
fi
rv=1
if [[ $cmd == "help" && -n $arg ]]; then
showcmdhelp "$arg"
rv=$?
elif [[ $admin -eq 1 ]]; then
case ${cmd} in
ls)
listservers
rv=$?
;;
lp)
listprojects
rv=$?
;;
p)
setproject "${arg}"
rv=$?
start_recache_if_needed
;;
c)
start_recache
rv=$?
[[ $rv -ne 0 ]] && error "UUID re-cache is already in progress (PID $recache_pid)"
;;
sc)
if [[ -z ${arg} ]]; then
for x in ${!uuid_id[@]}; do
echo "UUID: ${uuid_id[$x]} -> ${uuid_name[$x]}"
done
else
echo " UUID ${arg} -> $(uuid_to_name ${arg})"
fi
;;
q)
DONE=1
;;
help)
listcommands ADMIN
;;
*)
error "Admin command '$cmd' not implemented"
rv=1
;;
esac
else
case ${cmd} in
list|show)
getdata ${whattolist} $cmd ${opts[@]} >"$TMPFILE"
rv=$?
[[ -e $TMPFILE ]] && cat "$TMPFILE" | $pipe
if [[ $rv -eq 0 ]]; then
local timestr
timestr=$(printf "query time: %s seconds" "$lastqsecs")
[[ -n $lastprocsecs ]] && timestr="${timestr}$(printf ", processing time: %s secs" "$lastprocsecs")"
echo
info "$timestr"
fi
rm -f "$TMPFILE"
;;
action)
# TODO: ooremove any output format opts
validate_action ${endpoint} $actionname
if [[ $? -ne 0 ]]; then
error "'$actionname' is not a valid action for ${endpoint}s"
return 1
fi
epidx=$(getepidx $endpoint)
if [[ $? -ne 0 ]]; then
error "'$endpoint' is not a valid endpoint"
return 1
fi
# Get a list of objects to operate on
# ie. turn regexp into a list of dcs and obnames first
getdata ${whattolist} list $actionfilter $showerroropt -c -s -q >"$TMPFILE"
rv=$?
if [[ $rv -ne 0 ]]; then
error "Query for matching ${whattolist}s failed."
rv=1
elif [[ ! -e $TMPFILE ]]; then
error "No matching ${whattolist}s found."
rv=1
elif grep -q "no results" $TMPFILE; then
error "No ${whattolist}s found matching '$obname'."
rv=1
elif [[ ! -e $TMPFILE ]]; then
error "Results file does not exist."
rv=1
else
local ndcs nobs data confirm=0
ok
debug "tmpfile contents: [$(cat $TMPFILE)]"
echo
data=$(cat "$TMPFILE" | egrep -v "^$")
# how many servers?
ndcs=$( printf %d $(echo "$data" | awk -F, '{ print $1 }' | sort -u | wc -l))
[[ $ndcs -eq 1 ]] && dc_ess="" || dc_ess="s"
nobs=$( printf %d $(echo "$data" | awk -F, '{ print $2 }' | sort -u | wc -l))
[[ $nobs -eq 1 ]] && ob_ess="" || ob_ess="s"
if [[ $actionname == "connect" ]]; then
if [[ $nobs -gt 1 ]]; then
error "Can't run '$actionname' with multiple objects"
return 1
else
confirm=1
fi
elif [[ $actionname == "add" ]]; then
local allobs alluuids o_arr ou_arr
allobs=$(echo "$data" | awk -F, '{ print $2 }' | sort -u)
alluuids=$(echo "$data" | awk -F, '{ print $3 }' | sort -u)
o_arr=($allobs)
ou_arr=($alluuids)
if [[ $nobs -gt 1 ]]; then
local o n
info "Matched multiple ${whattolist}s:"
newtype=""
while [[ -z $newtype ]]; do
echo
n=1
while read -r o; do
printf "%3d. %s\n" $n "${o_arr[$n]}"
n=$((n + 1))
done <<<"$allobs"
echo
getstr ":" "" "Select one (q to abort)"
if [[ -n $retstr ]]; then
if [[ $retstr == "q" ]]; then
break
elif [[ $retstr =~ ^[0-9]*$ ]]; then
if [[ $retstr -le 0 || $retstr -ge $n ]]; then
error "Invalid selection"
else
newtype="${o_arr[$retstr]}"
newtype_uuid="${ou_arr[$retstr]}"
fi
else
local matched=0 x allmatches="" this thisuuid
for x in ${!o_arr[@]}; do
this="${o_arr[$x]}"
thisuuid="${ou_arr[$x]}"
shopt -s nocasematch
if [[ ${this} =~ $retstr ]]; then
newtype="$this"
newtype_uuid="$thisuuid"
allmatches="$allmatches [$this]"
matched=$((matched + 1))
fi
shopt -u nocasematch
done
if [[ $matched -eq 0 ]]; then
error "'$retstr' doesn't match any choice"
newtype=""
elif [[ $matched -gt 1 ]]; then
error "'$retstr' matched multiple choices: $allmatches"
newtype=""
fi
fi
fi
done
else
newtype="$allobs"
newtype_uuid="$alluuids"
fi
if [[ -z $newtype ]]; then
confirm=0
else
notify_nodots "Adding a new ${BOLD}$newtype${PLAIN}${PURPLE} named $BOLD$newname${PLAIN}"
confirm=1
fi
else
echo -e "${PURPLE}About to run '${BOLD}$actionname${PLAIN}${PURPLE}' on ${BOLD}${nobs}${PLAIN}${PURPLE} ${whattolist}${ob_ess} on ${BOLD}${ndcs}${PLAIN}${PURPLE} server${dc_ess}:${PLAIN}"
echo "$data" | awk -F, "BEGIN {lastdc=\"\"} { if (\$1 != lastdc) { print \" ${YELLOW}- ${BOLD}\" \$1 \"${PLAIN}\"; lastdc=\$1; } print \" ${YELLOW}- \" \$2 \"${PLAIN}\"}"
echo
if [[ $ndcs -le 1 ]]; then
getyn n "Really proceed"
[[ $? -eq 0 ]] && confirm=1 || confirm=0
else
local confirmcode entered_string
confirmcode=$(generate_random_string)
notify_nodots "Confirmation code is: ${BOLD}${confirmcode}${PLAIN}"
getstr ":" "n" "Enter the above code to proceed, anything else will abort"
entered_string="$retstr"
[[ $entered_string == $confirmcode ]] && confirm=1 || confirm=0
fi
fi
if [[ $confirm -eq 1 ]]; then
if [[ $actionname == "add" ]]; then
# We use alternate values for the actiontarget string here:
# loc=servername (normal)
# ob=name of new ob to add
# obuuid=uuid of model
# extrainfo=curl post data
actiontargets="$curlocs,$newname,$newtype_uuid"
# ooo
#actiontargets="${actiontargets},'{\"name\": \"$newname\", \"node_type\": \"$newtype\", \"compute_id\": \"local\"}'"
actiontargets="${actiontargets},name:$newname^node_type:$newtype^compute_id:local"
else
actiontargets=$(echo "$data")
fi
if [[ $actionname == "connect" ]]; then
local devname sevname srvport
devname=$(echo "$data" | awk -F, '{ print $2 }')
srvname=$(echo "$data" | awk -F, '{ print $1 }')
srvport=$(echo "$data" | awk -F, '{ print $4 }')
notify_nodots "Connecting to $devname ($srvname:$srvport)"
opts+=("-F")
else
notify "Submitting actions to gns API"
fi
rm -f "$TMPFILE"
debug "about to call runaction with:"
debug " obtype = $endpoint"
debug " actionname = $actionname"
debug " actiontargets = $actiontargets"
debug " opts = ${opts[@]}"
debug " outputfile = ${TMPFILE}"
runaction ${endpoint} $actionname "$actiontargets" ${opts[@]} >"$TMPFILE"
rv=$?
if [[ $actionname != "connect" ]]; then
ok
[[ -e $TMPFILE ]] && cat "$TMPFILE" | $pipe
echo
info $(printf "action submission time: %s seconds" "$lastqsecs")
fi
fi
fi
rm -f "$TMPFILE"
;;
exit)
DONE=1
;;
help)
listcommands NOADMIN
;;
*)
error "Command '$cmd' not implemented"
rv=1
;;
esac
fi
return $rv
}
function setproject() { # setproject [project_name]
local newproj x err rv idx
newproj="${1}"
err=0
if [[ -z $newproj ]]; then
newproj=${proj_name[0]}
if [[ -z $newproj ]]; then
error "Could not set default project - none found on server!"
return 1
fi
fi
idx=$(getprojidx ${newproj})
if [[ $? -ne 0 ]]; then
error "invalid project '$newproj'"
err=1
fi
curprojid=${proj_id[$idx]}
if [[ $err -eq 0 ]]; then
curproj="${newproj}"
info "Project set to: $curproj ($curprojid)"
rv=0
else
rv=1
fi
return $rv
}
function checkfor() { # checkfor name [pkg_name]
local what pkgname
local hw os ok=0 confirm=0
local alt rv
what=$1
pkg_name=${2:-$what}
os=$(uname -s)
hw=$(uname -m)
if [[ $hw == "aarch64" ]]; then # Android Termuz
alias which="command -v"
fi
which $what >/dev/null 2>&1
rv=$?
if [[ $rv -ne 0 && $what == "gdate" ]]; then
date --version 2>/dev/null | grep -q GNU 2>/dev/null
if [[ $? -eq 0 ]]; then
GDATE=$(which date 2>/dev/null)
what=${GDATE}
rv=0
fi
fi
if [[ $? -eq 0 ]]; then
ok=1
else
error "$what binary not found in \$PATH."
getyn n "Try to install it?"
[[ $? -eq 0 ]] && confirm=1 || confirm=0
if [[ $confirm -eq 1 ]]; then
case $os in
Darwin)
brew install $pkg_name && ok=1
;;
Linux)
if [[ -f /etc/debian_version ]]; then
apt-get install $pkg_name && ok=1
elif [[ -f /etc/redhat_release ]]; then
apt-get install $pkg_name && ok=1
fi
;;
*)
echo "Don't know how to install stuff on OS '$os'"
;;
esac
[[ $ok -eq 1 ]] && info "Successfully installed $pkg_name" || error "Failed to install $pkg_name"
fi
fi
which $what >/dev/null 2>&1
return $?
}
function killtmux() {
tmux kill-session -t "$1" >/dev/null 2>&1
}
function cleanup() {
local x
echo
notify "Killing remaining tmux sessions"
for x in ${proj_name[@]}; do
killtmux "$x"
done
ok
notify "Cleaning up temporary files"
[[ -n $TMPDIR && -d $TMPDIR ]] && rm -f "$TMPDIR/*"
ok
}
function processarg() {
case "$i" in
h)
usage;
exit 1;
;;
I)
scriptstoinline
exit $?;
;;
i)
initauth;
exit $?;
;;
p)
DEFPROJECT="${OPTARG}"
;;
P)
PROFILING=1
;;
v)
VERBOSE=1
info verbose mode
;;
*)
error "invalid argument: $i";
usage;
;;
esac
}
function loadservers() {
local sname shost sport
if [[ -e $SRVFILE ]]; then
notify "Loading servers from $SRVFILE"
while read -r f ; do
sname=$(echo "$f" | awk -F: '{ print $1 }')
shost=$(echo "$f" | awk -F: '{ print $2 }')
sport=$(echo "$f" | awk -F: '{ print $3 }')
if [[ -z $sname || -z $shost || -z $sport ]]; then
fail
error "Bad line in server file: $f"
return 1
fi
addloc $sname $shost $sport
done < <(egrep -v "(^#|^$)" $SRVFILE)
fi
ok "Got $nlocs servers"
return 0
}
BOLD="\033[1m"
PLAIN="\033[0m"
ITALIC="\033[3m"
UNDERLINE="\033[4m"
RED="\033[31m"
YELLOW="\033[33m"
GREEN="\033[32m"
BLUE="\033[34m"
PURPLE="\033[35m"
CYAN="\033[36m"
LINK="$BLUE$UNDERLINE"
UNDERLINE_PRINTED=$(echo -en "$UNDERLINE")
UNDERLINE_LENGTH=${#UNDERLINE_PRINTED}
# Generate sed script to add colours to certain words
UUIDCHAR="[0-9a-f]"
UUID_REGEXP=${UUIDCHAR}\{8\}-${UUIDCHAR}\{4\}-${UUIDCHAR}\{4\}-${UUIDCHAR}\{4\}-${UUIDCHAR}\{12\}
WORDCOLOURS=( "${GREEN}" "${RED}" "${YELLOW}" )
UUIDCOL="$PURPLE"
COLOURED_WORDS=( "true\|up\|enabled\|complete\|finished\|started\|opened" "false\|down\|paused\|uninitialized\|disabled\|failed\|stopped\|closed" "migrating\|powering_up\|project_closed\|unknown" )
ADD_COLOURS=""
for colidx in ${!WORDCOLOURS[@]}; do
col=${WORDCOLOURS[$colidx]}
ADD_COLOURS="${ADD_COLOURS}s/\b\(${COLOURED_WORDS[$colidx]}\)\b/\\${col}\\1\\${PLAIN}/g;"
done
ADD_COLOURS="${ADD_COLOURS}s/\(${UUID_REGEXP}\)/${UUIDCOL}\\1${PLAIN}/g"
nlocs=0
neps=0
# addendpoint ep_name ep_apiendpoint ep_jqobjectname idfieldname [defaultfieldname]
addendpoint projects projects project project_id name
addepalias projects p
addeptitles projects "Project " "UUID" "Status "
addepfields projects ".name" ".project_id" ".status"
addepactions projects open close
addendpoint nodes projects/_CURPROJECT_/nodes node node_id name
addepalias nodes n
addeptitles nodes "Node " "Model_UUID" "Status " "Console_Port"
addepfields nodes ".name" ".template_id" ".status" ".console"
addepactions nodes start stop connect add
addendpoint links projects/_CURPROJECT_/links link link_id link_id
addepalias links l
addeptitles links "Type" "A-Host_UUID " "A-Port" "Z-Host_UUID " "Z-Port"
addepfields links ".link_type" ".nodes[0].node_id" ".nodes[0].label.text" ".nodes[1].node_id" ".nodes[1].label.text"
addendpoint models templates model template_id name
addepalias models m
addeptitles models "Name" "Category" "UUID"
addepfields models ".name" ".category" ".template_id"
addcmd list "List elements of a given type (eg. nodes, links, etc)" 1+ ls l
addcmdusage list "object_type [regexp_filter]" "object_type can be: [${ep_name[*]}]"
addcmdoption list "-n" "Don't resolve UUIDs to names"
addcmdoption list "-o filename" "Send output to 'filename'"
addcmdoption list "-r" "Raw mode - show raw JSON from gns API"
addcmdoption list "-v" "Verbose mode - show object details"
addcmd show "Show detail of a given element (eg. compute node, VM, etc)" 2 sh
addcmdusage show "object_type [regexp_filter]" "object_type can be: [${ep_jqobj[*]}]"
addcmdoption show "-n" "Don't resolve UUIDs to names"
addcmdoption show "-o filename" "Send output to 'filename'"
addcmdoption show "-r" "Raw mode - show raw JSON from gns API"
addcmd action "Perform action on given object." 3 act do
declare -a lines
for x in ${!ep_jqobj[@]}; do
if [[ -z ${ep_validactions[$x]} ]]; then
lines+=("${ep_jqobj[$x]} actions: n/a")
else
lines+=("${ep_jqobj[$x]} actions: ${ep_validactions[$x]}")
fi
done
addcmdusage action "object_type action_type regexp_filter" "object_type can be: [${ep_jqobj[*]}]" "" "${lines[@]}"
addcmdoption action "-f" "Force - don't ask for confirmation"
addcmdalias "open" "action project open" "_CURPROJECT_"
addcmdalias "close" "action project close" "_CURPROJECT_"
addcmdalias "start" "action node start" ""
addcmdalias "stop" "action node stop" ""
addcmdalias "connect" "action node connect" ""
addcmdalias "c" "action node connect" ""
addcmdalias "add" "action node add" ""
addcmd help "List regular commands" 0 "?" "h"
addcmd exit "Exit from gnscli" 0 quit
addcmd -a help "List admin commands" 0 "?" "h"
addcmd -a p "Select project filter (comma or space separated list)" 1 loc
addcmdusage p "project_list" "project_list is a comma-separated list made up of [${loc_name[*]}]"
addcmd -a lp "List GNS3 projects on current server(s)" 0 listprojects
addcmd -a ls "List GNS3 servers" 0 listservers l
addcmd -a c "Re-cache UUIDs for current projects" 0 cache
addcmd -a sc "Show cached name for given UUID (or all UUIDs if none provided)." 0-1 showcache
addcmdusage sc "[uuid]" "If UUID is not provided, all UUID-to-name mappings are shown."
addcmd -a q "Exit from gnscli" 0
VERBOSE=0
GDATE="gdate"
CONFDIR="$HOME/.gnscli"
HISTFILE="$CONFDIR/history"
TMPDIR="$CONFDIR/tmp"
SCRIPTDIR="$CONFDIR/scripts"
#HEADINGFILE="$CONFDIR/head.tmp"
TMPFILE="$TMPDIR/temp.tmp"
TOTFILE="$TMPDIR/tot.tmp"
#AUTHFILE="$CONFDIR/auth"
CACHEDIR="$CONFDIR/uuid_cache"
CACHEFILEBASE="$CACHEDIR/mappings"
RCFILE="$CONFDIR/rc"
SRVFILE="$CONFDIR/servers"
UUIDLENGTH=36
CACHING=""
PROFILING=0
DEFPROJECT=""
curproj=""
nmsgq=0
recache_pid=""
THISSCRIPT="$0"
RCARGS=""
if [[ -e $RCFILE ]]; then
info "processing $RCFILE"
while read -r f ; do
RCARGS="$f $ALLARGS"
done < <(egrep -v "(^#|^$)" $RCFILE)
fi
VALIDARGS="hiIp:Pv"
while getopts "$VALIDARGS" i $RCARGS; do
processarg "$i"
done
OPTIND=0
while getopts "$VALIDARGS" i ; do
processarg "$i"
done
shift $((OPTIND - 1))
if [[ ! -e $TMPDIR ]]; then
error "Temporary file dir $TMPDIR doesn't exist. Use -i to create it."
exit 1
else
rm -fr ${TMPDIR}/*.tmp
rm -fr ${TMPDIR}/get.*
rm -fr ${TMPDIR}/run.*
fi
if [[ ! -d $CONFDIR ]]; then
error "Configuration directory $CONFDIR doesn't exist. Use -i to create it."
exit 1
fi
checkfor gdate coreutils jq || exit 1
loadservers
if [[ $nlocs -lt 1 ]]; then
error "No servers found - check $SRVFILE"
exit 1
fi
alllocs=$(getalllocs)
# prepopulate list of projects
notify "Getting initial projectlist"
oldverbose=$VERBOSE
VERBOSE=1
errfile="$TMPDIR"/err
output=$(getdata projects show -e -r 2>"$errfile")
rv=$?
VERBOSE=$oldverbose
if [[ $rv -eq 0 ]]; then
ok
#cat "$errfile"
rm -f "$errfile"
jqoutput=$(echo "$output" | jq -r '.[] | .project_id + "|" + .name' 2>"$errfile")
rv=$?
if [[ $rv -ne 0 || -z $jqoutput ]]; then
error "$rv Got bad data from initial project list query to API"
echo -e "${RED}${BOLD}Errors:${PLAIN}"
echo -en "${RED}"
cat "${errfile}" | sed -e 's/^/ /'
echo -en "${PLAIN}"
rm -f "$errfile"
exit 1
fi
rm -f "$errfile"
for x in $jqoutput; do
id=${x%|*}
name=${x#*|}
addproject $id $name
done
else
fail
error "Could not obtain initial project list from API"
echo -e "${RED}${BOLD}Output:${PLAIN}"
echo -en "${RED}"
echo "${output}" | sed -e 's/^/ /'
echo -en "${PLAIN}"
echo -e "${RED}${BOLD}Errors:${PLAIN}"
echo -en "${RED}"
cat "${errfile}" | sed -e 's/^/ /'
echo -en "${PLAIN}"
rm -f "$errfile"
exit 1
fi
if [[ ${#proj_id[@]} -eq 0 ]]; then
error "No projects found on server!!"
exit 1
fi
setproject $DEFPROJECT || exit 1 # defaults to first one
[[ -e $HISTFILE ]] && history -r "$HISTFILE"
loadcachefile $curlocs
dumpmsgq
trap cleanup EXIT
echo "Unofficial GNS3 cli v${VER}"
echo -e "${ITALIC}${YELLOW}Note: this script is still in development and may have bugs!${PLAIN}"
if [[ $# -gt 0 ]]; then
processcmd $*
else
DONE=0
while [[ $DONE -ne 1 ]]; do
lastqsecs=0
#echo -en "${pstr}"
getcmd cmd || break
set -f
processcmd $cmd
set +f
if [[ ! -z $cmd ]]; then
history -s "$cmd"
history -w "$HISTFILE"
fi
dumpmsgq # show any queued messages
done
fi
exit 0
#START_INLINE:model.jq
"UUID#" + .template_id,
"Name#" + .name,
"Usage#" + .usage,
"Category#" + .category,
"RAM#" + .ram + "MB",
"Action on close#" + .on_close,
"Firewall Type#" + .firewall_type,
"Image#" + .hda_disk_image,
"__END__"
#END_INLINE:model.jq
#START_INLINE:project.jq
"UUID#" + .project_id,
"Name#" + .name,
"Status#" + .status,
"Filename#" + .filename,
"Path#" + .path,
"Auto-Open#" + .auto_open,
"Auto-Close#" + .auto_close,
"Auto-Start#" + .auto_start,
"__END__"
#END_INLINE:project.jq
#START_INLINE:detail.awk
BEGIN {
FS="#"
nlines=0
BOLDBLUE="\033[1m\033[36m"
PLAIN="\033[0m"
}
{
key[nlines]=$1
val[nlines++]=$2
if (length($1)>max) max=length($1);
}
END {
nvalid=0
for (i=0;i<nlines;i++) {
if (length(key[i]) + length(val[i]) >= 1) {
printf( BOLDBLUE"%" max "s:" PLAIN " %s\n",key[i],val[i]);
nvalid++;
}
}
if (nvalid >= 1) printf(" \n");
}
#END_INLINE:detail.awk
#START_INLINE:node.jq
"Hostname#" + .name,
"UUID#" + .node_id,
"Model UUID#" + .template_id,
"Project UUID#" + .project_id,
"Status#" + .status,
"Port format#" + .port_name_format,
"Locked#" + (.locked // "n/a"),
"Console port#" + ((.console|tostring) // "n/a"),
"Port count#" + try (.ports[] | length) catch ("unknown"),
#END_INLINE:node.jq
#START_INLINE:link.jq
"UUID#" + .link_id,
"Type#" + .link_type,
"Project UUID#" + .project_uuid,
"A-Node#" + .node[0].node_id,
"A-Port#" + .node[0].label.text,
"Z-Node#" + .node[1].node_id,
"Z-Port#" + .node[1].label.text,
"Capturing#" + .capturing,
"Suspended#" + .suspend,
"__END__"
#END_INLINE:link.jq
Reference in New Issue View Git Blame Copy Permalink