utils

#!/usr/bin/env bash
#
# SPDX-FileCopyrightText: 2024 SAP SE or an SAP affiliate company and Gardener contributors
#
# SPDX-License-Identifier: Apache-2.0


set -e

source "$(dirname "$BASH_SOURCE")/stdio"

################################################################################
# standard error handling
################################################################################

catch()
{
  set +e
  (
    set -e
    "${@:2}"
  )
  eval $1=$?
  set -e
}

errorHandler=( )

TMP_NAME=/tmp/sow$$-

declare -Ag cleanup_handlers

handle_interrupt()
{
  handle_error
  cleanup_handlers=( )
  exit 126
}

handle_error()
{
  x=${1:-$?}
  if [ ${#errorHandler[@]} -ne 0 ]; then
    "${errorHandler[@]}"
  fi

  set +x
  if [ -n "$STACKTRACE" ]; then
    warn "ERRCODE $x (subshell $BASH_SUBSHELL) INTEND=$INTENDED_EXIT"
  fi
  if [ -z "$SOWID" -o ! -f "$SOWID" ]; then
    if [ $x -ne 0 -a -n "$STACKTRACE" -a \( -z "$INTENDED_EXIT" -o -n "$DEBUG" \) ]; then
        print_stacktrace 1
        if [ -n "$SOWID" ]; then
          touch "$SOWID"
        fi
    else
      if [ "$BASH_SUBSHELL" = "0"  ]; then
        if [ -n "$SOWID" ]; then
          rm -f "$SOWID"
        fi
      fi
    fi
    INTENDED_EXIT=X
    DEBUG=
  fi

  if [ "$BASH_SUBSHELL" = "0" ] && [ -n ${INSTALLATION_HANDLER:-""} ]; then
    if [ ! -x "$INSTALLATION_HANDLER" ]; then
      fail "no executable installation handler script found at '$INSTALLATION_HANDLER'"
    fi
    exec_cmd "$INSTALLATION_HANDLER" finalize "$INSTALLATION_HANDLER_CONFIG"
  fi
  rm -f "${TMP_NAME}"*
  
  local h
  for h in "${!cleanup_handlers[@]}"; do
    local p="$(expr "$h" : '.*-\([0-9]*\)')"
    if [ -n "$p" ]; then
      if [ $p -ne $BASHPID ]; then
        continue
      fi
      h="$(expr "$h" : '\(.*\)-[0-9]*')"
    fi
    $h
  done

  if [ -z "$INTENDED_EXIT" ]; then
    if [ -n "$PLUGINCONFIG" -a -f "$PLUGINCONFIG" ]; then
      rm -f "$PLUGINCONFIG"
    fi
  fi
}

addCleanupHandler()
{
  local h
  for h; do
    cleanup_handlers[$h]=$((cleanup_handlers[$h] + 1 ))
  done
}
addLocalCleanupHandler()
{
  local h
  for h; do
    if [ -z "${cleanup_handlers[$h]}" ]; then
      h="$h-$BASHPID"
    fi
    cleanup_handlers[$h]=$((cleanup_handlers[$h] + 1 ))
  done
}
_removeCleanupHandler()
{
  local h
  for h; do
    cleanup_handlers[$h]=$((cleanup_handlers[$h] - 1 ))
    if [ ${cleanup_handlers[$h]} -le 0 ]; then
      unset cleanup_handlers[$h]
    fi
  done
}
removeCleanupHandler()
{
  local h
  for h; do
    _removeCleanupHandler "$h" "$h-$BASHPID"
  done
}

StandardErrorHandling()
{
  if [ -n "$STACKTRACE" ]; then
    color_dark SUBSHELL$BASH_SUBSHELL
  fi
  if [ "$BASH_SUBSHELL" = "0" ]; then
    export "SOWID=/tmp/sowid=$$"
  fi
  set -e
  export INTENDED_EXIT=
  trap handle_error ERR EXIT
  trap handle_interrupt INT
}

ExecuteInSubshell()
{
  (
    StandardErrorHandling
    "$@"
  )
}

StandardErrorHandling

if [ -n "$TRACE" ]; then
  set -x
fi

################################################################################
# standard utils
################################################################################

header_message()
{
  if [ -n "${!1}" ]; then
    ${2:-info} "${!1}"
    eval $1=
  fi
}

add_functions()
{
  local a
  local b
  local f
  local cmds
  while read a b f; do
    if [[ "$f" = ${2}* ]]; then
      f="${f#$2}"
      eval "cmds=( \"\${$1[@]}\" )"

      if ! contains "$f" "${cmds[@]}"; then
        eval "$1=( \"\${cmds[@]}\" \"$f\" )"
      fi
    fi
  done < <(typeset -F)
}
#
# print the actual stacktrace
# $1: number of omitted stack enries
# $2+ title
#
print_stacktrace()
{
  local i=1
  if [ -n "$1" ]; then
    i=$(($1+1))
  fi

  while [ $i -lt ${#BASH_SOURCE[@]} ]; do
    local line="${BASH_LINENO[$i-1]}"
    echo "${FUNCNAME[$i]} [${BASH_SOURCE[$i]}+$line]"
    i=$((i+1))
  done | (
    _start_color "${COLOR_RED}";
    echo "*** stack trace ${@:2}"
    echo "command: $BASH_COMMAND"
    column -t -s "  ";
    _end_color
  ) >&2
}

# $1: base dir
# $2: file/dir below base dir
rm_directory_and_cleanup_tree()
{
  if [ -z "$1" ]; then
    fail base directory missing
  fi
  if [[ "$2" != "$1"/* ]]; then
    fail "$2" is not below "$1"
  fi
  rm -rf "$2"
  find "$1" -type d -empty -delete
}

exec_cmd() {
  if [ -n "$DRYRUN" ]; then
    echo "$@"
  else
    if [ -n "$VERBOSE" ]; then
      echo "$@"
    fi
    "$@"
  fi
}

_is_function()
{
   [ "$(type -t "$1")" == function ]
}

_is_number()
{
  if [[ "$1" =~ ^[0-9]+$ ]]; then
    return 0
  else
    return 1
  fi
}

#
# res: result associative array
# read successive lines with key and value
# and add to the associative array
_read_hash()
{
  local line
  hash=( )
  while  read -r label value; do
    if [ -n "$label" ]; then
      eval $1[\"\$label\"]=\"\$value\"
    fi
  done
}

contains()
{
  local i
  local elem="$1"
  shift
  for i in "$@"; do
    if [ "$i" == "$elem" ]; then
      return 0
    fi
  done
  return 1
}

trim()
{
  if [ $# -gt 0 ]; then
    trim <<<"$1"
  else
    sed -e 's/^\s*//' -e 's/\s*$//'
  fi
}

join() {
  local sep=$1 IFS=
  local ret=$2
  shift 2 || shift $(($#))
  ret+="${*/#/$sep}"
  echo "$ret"
}

addHashed()
{
  local v
  for v in "${@:2}"; do
    eval "$1[\"$v\"]=X"
  done
}

prependOrderedSet()
{
  local a=( )
  eval a="( \"\${$1[@]}\" )"
  local o
  for o in "${@:2}"; do
    if ! contains "$o" "${a[@]}"; then
      a=( "$o" "${a[@]}" )   
    fi
  done
  eval "$1"="( \"\${a[@]}\" )"
}

appendOrderedSet()
{
  local a=( )
  eval a="( \"\${$1[@]}\" )"
  local o
  for o in "${@:2}"; do
    if ! contains "$o" "${a[@]}"; then
      a=( "${a[@]}" "$o" )   
    fi
  done
  eval "$1"="( \"\${a[@]}\" )"
}

appendList()
{
  local a=( )
  eval a="( \"\${$1[@]}\" )"
  local o
  for o in "${@:2}"; do
    a=( "${a[@]}" "$o" )   
  done
  eval "$1"="( \"\${a[@]}\" )"
}

removeList()
{
  local a=( )
  eval a="( \"\${$1[@]}\" )"
  local n=( )
  local o
  for o in "${a[@]}"; do
    if ! contains "$o" "${@:2}"; then
      n=( "${n[@]}" "$o" )   
    fi
  done
  eval "$1"="( \"\${n[@]}\" )"
}

setReverse()
{ 
  local a=( )
  local o
  for o in "${@:2}"; do
    a=( "$o" "${a[@]}" )   
  done
  eval "$1"="( \"\${a[@]}\" )"
}

setUniq()
{ local a=( )
  local v
  
  for v in "${@:2}"; do
    if ! contains "$v" "${a[@]}"; then
      a=( "${a[@]}" "$v" )
    fi
  done
  eval "$1"="( \"\${a[@]}\" )"
}

executionLoop()
{
  local cmd="$1"
  local var="$2"
  local _values=( )
  shift 2

  eval _values=( \"\${"$var[@]"}\" )

  local _i
  local _n=${#_values[@]}

  if [ $_n -eq 0 ]; then
    return
  fi
  for _i in $(seq 0 $((_n - 1))); do
    if [ "$cmd" == delete ]; then
      _i=$((_n - _i - 1))
      order=tac
    else
      order=cat
    fi
    "$1" "$cmd" $_i "${_values[$_i]}" "${@:2}"
  done
}

isAbsolutePath()
{
  test "${1#/}" != "$1"
}

################
# get absolute path for a path
#
# $1 : relative filename (at least directory must exist)
################
abspath()
{
  if [ -d "$1" ]; then
    ( cd "$1"; pwd )
  else
    local p="${1%%/}"
    local t
    while t="${p%%/.}"; [ "$p" != "$t" ]; do
      p="${t%%/}"
    done
    p="$(cd "$(dirname "$p")" && pwd)/$(basename "$p")"
    t="${p%%/..}"
    [ "$t" == "$p" ] && echo "$p" || dirname "$t"
  fi
}

################
# get relative path
# 
# $1: base path   (from)
# $2: target path (to)
################
relpath()
{
  [ $# -ge 1 -a $# -le 2 ] || Error two paths required
  local current="${2:+"$1"}"
  local target="${2:-"$1"}"
  [ "$target" != . ] || target=/
  target="/${target##/}"
  [ "$current" != . ] || current=/
  current="${current:="/"}"
  current="/${current##/}"
  local appendix="${target##/}"
  local relative=''
  while appendix="${target#"$current"/}"
      [ "$current" != '/' ] && [ "$appendix" = "$target" ]; do
      if [ "$current" = "$appendix" ]; then
          relative="${relative:-.}"
          echo "${relative#/}"
          return 0
      fi
      current="${current%/*}"
      relative="$relative${relative:+/}.."
  done
  relative="$relative${relative:+${appendix:+/}}${appendix#/}"
  echo "$relative"
}

############################################################################
# yaml and json access
############################################################################

#
# get a value field from json
#
_jq_get_value()
{
  jq -r "($1)? // empty"
}

_jq_get_value_for_shell()
{
  jq -r "select($1 != null) | $1  | @sh"
}

# get second argument if first one not found
_jq_get_defaulted_value()
{
  jq -r '('$1') // "'$2'"'
}

# get second argument shell-escaped, if first one not found
_jq_get_defaulted_value_for_shell()
{
  jq -r '(('$1') // "'$2'" ) | @sh'
}

_jq_get_json()
{
  jq -r "(($1) // empty) | tojson"
}

_jq_get_json_for_shell()
{
  jq -r "(($1) // empty) | tojson | @sh"
}

_jq_get_value_or_json_for_shell()
{
  jq -r '(('"$1"') // empty) | if type == "array" or type == "object" then [ "json", tojson ] else [ "value", . ] end | @sh'
}

_jq_get_value_list_for_shell()
{
  local value="$(echo "${3:-$1}" | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g')"
  jq -r '(('"$1"') // empty) | if type == "array" then . elif type == "object" then error("expected list for '"$value"'") else [.] end | @sh'
}

_jq_get_json_list_for_shell()
{
  local value="$(echo "${3:-$1}" | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g')"
  jq -r '(('"$1"') // empty) | if type == "array" then . elif type != "object" then error("expected list for '"$value"'") else [.] end | .[] | tojson | @sh'
}

_jq_get_json_map_for_shell()
{
  local value="$(echo "${3:-$1}" | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g')"
  jq -r '(('"$1"') // empty) | if type == "array" then . elif type != "object" then error("expected map for '"$value"'") else [.] end | .[] | tojson | @sh'
}

_JQ_SHELLVALUE='if type == "object" or type == "array" then tojson else . end | @sh'

#
# get list of map fields formatted to assigned to an associative array
#
_jq_get_json_map_for_shell()
{ 
  local value="$(echo "${2:-$1}" | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g')"
  jq -r '('"$1"') // {} | if type == "object" then . as $m | keys[] | ["[", (.|@sh) , "]=", ($m[.]|'"$_JQ_SHELLVALUE"')] | join("") else error("expected map for '"$value"'")  end'
}

#
# get list of map fields of type map formatted to assigned to an associative
# array matching a selection criteria
#
# $1: map expression
# $2: jq select expression
# [$3]: field description for error message
#
_jq_get_selected_json_map_entries_for_shell()
{ 
  local value="$(echo "${3:-$1}" | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g')"
  jq -r '('"$1"') // {} | if type == "object" then . as $m | keys[] | . as $k | $m[.] | select('"$2"') | ["[", ($k|@sh) , "]=", (.|'"$_JQ_SHELLVALUE"')] | join("") else error("expected map for '"$value"'")  end'
}


#
# extract a label mapping list from json
# supporting different formats: lists, objects or single values
# result:   sequence of "<label> <value>" pairs
# result:   sequence of bash associative array litaral entries
#
_jq_get_labeled_value_list()
{
  jq -r '('$1' // []) | if type == "object" then . as $m | keys[] | [.,$m[.]] elif type == "array" then .[] | if type == "object" then . as $m | keys[] | [.,$m[.]] else [.,.] end else . end | ["[", (.[0]|@sh) , "]=", (.[1]|'"$_JQ_SHELLVALUE"')] | join("")'
}


#
# extract a sequence of labeled arg lists from json
# result: sequence of "<arg1>" .. "<argn>" tupels
#
#_jq_get_labeled_arg_list()
#{
#  jq -r '('$1' // empty) | if type == "array" then .[] | if type == "object" then . as $m | keys[] | [ .,  ($m[.] | if type == "array" then .[] else . end)] else [.] end elif type == "object" then . as $m | keys[] | [ ., $m[.][]] else [.] end | @sh '
#}

#
# extract a sequence of plugin specs
# - plugin
# - plugin: arg
# - plugin:
#   - arg1
#   - arg2
# - plugin:
#     config: ...
#     args: 
#       - arg1
#       - arg2
# result: sequence of "<arg1>" .. "<argn>" tupels
#
_jq_get_plugin_list_for_shell()
{
  jq -r '(('"$1"') // empty) | [
       if type == "array" then
          .[] 
       elif type == "object" then
         .
       else
         . 
       end | if type == "array" then 
               if ( . | length) == 0 then
                 error("empty list not supported as plugin spec")
               else
                 { name: .[0], args: .[1:] }
               end
             elif type == "object" then
                if has("name") then
                 .
               else
                 . as $p | keys[] | . as $n | $p[.] | if type == "array" then
                   { name: $n, args: . }
                 elif type == "object" then
                   { name: $n } + .
                 else
                   { name: $n, args: [.] }
                 end
               end
             else
               { name: ., args: [] }
             end | tojson
     ] '"$2"' | @sh'
}



__get() {
  if [ -n "$3" ]; then
     v="$(echo "${!3}" | $1 ".$2" "${@:4}")"
  else
     v="$($1 ".$2")"
  fi
}

_get_value() {
  __get _jq_get_value_for_shell "${@:2}"
  eval $1="$v"
}

_get_json() {
  __get _jq_get_json_for_shell "${@:2}"
  eval $1="$v"
}

_get_value_list() {
  __get _jq_get_value_list_for_shell "${@:2}"
  eval $1="( $v )"
}

_get_json_list() {
  __get _jq_get_json_list_for_shell "${@:2}"
  eval $1="( $v )"
}

_get_value_or_json() {
  __get _jq_get_value_or_json_for_shell "${@:2}"
  eval $1="( $v )"
}

_get_json_map()
{
  __get _jq_get_json_map_for_shell "${@:2}"
  eval $1="( $v )"
}

getJsonMap() {
  local v
  _get_json_map "$@"
}

_get_selected_json_map_entries()
{
  __get _jq_get_selected_json_map_entries_for_shell "$2" "$4" "$3" "${@:5}"
  eval $1="( $v )"
}

getSelectedJsonMapEntries()
{
  local v
  _get_selected_json_map_entries "$@"
}

#
# get a json field mapped to a string mapping
_get_labeled_value_list()
{
  __get _jq_get_labeled_value_list "${@:2}"
  eval $1="( $v )"
}

getLabeledValueList()
{
  local v
  _get_labeled_value_list "$@"
}

_get_config_value() {
  _get_value "$@" <<<"$CONFIGJSON"
}

getConfigValue() {
  local v
  _get_config_value "$@"
}

getRequiredConfigValue() {
  local v
  _get_config_value "${@}"
  eval v=$v
  if [ -z "$v" ]; then
    fail "configuration attribute '$2' is required"
  fi
}


_get_config_json() {
  _get_json "$@"  <<<"$CONFIGJSON"
}

getConfigJSON() {
  local v
  _get_config_json "$@"
}

getRequiredConfigJSON() {
  local v
  _get_config_json "${@}"
  eval v=$v
  if [ -z "$v" ]; then
    fail "configuration attribute '$2' is required"
  fi
}


_get_config_value_list() {
  _get_value_list "$@" <<<"$CONFIGJSON"
}

getConfigValueList() {
  local v
  _get_config_value_list "$@"
}

getRequiredConfigValueList() {
  local v
  _get_config_value_list "$@"
  eval v=( $v )
  if [ "${#v[@]}" -eq 0 ]; then
    fail "configuration attribute '$2' is required"
  fi
}



_get_config_json_list() {
  _get_json_list "$@" <<<"$CONFIGJSON"
}

getConfigJSONList() {
  local v
  _get_config_json_list "$@"
}

getRequiredConfigJSONList() {
  local v
  _get_config_json_list "$@"
  eval v=( $v )
  if [ "${#v[@]}" -eq 0 ]; then
    fail "configuration attribute '$2' is required"
  fi
}

#######################################


getKeys() {
  _get_value_list "$1" "| ((.$2) // {}) | keys" "$3"
}

getValue() {
  local v
  _get_value "$@"
}

getRequiredValue() {
  local v
  _get_value "${@}"
  eval v=$v
  if [ -z "$v" ]; then
    if [ -n "$4" ]; then
      fail "$4: configuration attribute '$2' is required"
    else
      fail "configuration attribute '$2' is required"
    fi
  fi
}

getJSON() {
  local v
  _get_json "$@"
}

getValueOrJSON() {
  local v
  _get_value_or_json "$@"
}

getValueList() {
  local v
  _get_value_list "$@"
}

getJSONList() {
  local v
  _get_json_list "$@"
}

getPluginList() {
  local v
  __get _jq_get_plugin_list_for_shell "${@:2}"
  eval $1="( $v )"
}

getValueMap() {
  local keys=( )
  getKeys keys "${@:2}"
  for k in "${keys[@]}"; do
    getValue "$1[$k]" $2['"'$k'"'] $3
  done
}

################################################################################
# json manipulation
################################################################################

deljsonkey() {
    local v
    v="$(echo "${!1}" | jq -r 'del(.'$2') | tojson |@sh')"
    eval $1="$v"
}

setjsonvalue() {
    local value="$(echo "$3" | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g')"
    local v
    v="$(echo "${!1}" | jq -r '.'$2'="'"$value"'" | tojson |@sh')"
    eval $1="$v"
}

setjsonjson() {
    local v
    v="$(echo "${!1}" | jq -sr '.[0].'"$2"'=.[1] | .[0] | tojson |@sh' - <( echo "${3}"))"
    eval $1="$v"
}

getjsonvalue() {
    eval echo \"\$"$1"\" | jq -r '.'"$2 // empty"
}

getrequiredjsonvalue() {
    local v
    v="$(getjsonvalue "$@")"
    if [ "$v" == null ]; then
        fail "field $2 required in $1"
    fi
    echo "$v"
}

################################################################################
# json composition
################################################################################

jsonAdd()
{
  local new
  if [ $# -eq 3 ]; then
    new="\"$2\": $3"
  else
    new="$2"
  fi

  if [ -n "${!1}" ]; then
    new="${!1}, $new"
  else
    new="$new"
  fi
  eval $1="\"\$new\""
}

jsonAddString()
{
  if [ $# -eq 3 ]; then
    jsonAdd "$1" "${2//\"/\\\"}" "\"${3//\"/\\\"}\""
  else
    jsonAdd "$1" "\"${2//\"/\\\"}\""
  fi
}

################################################################################
# file lookup
################################################################################

lookupFileIn() {
  local all
  local opt="-f"
  while [ $# -gt 0 ]; do
    case "$1" in
      -d) opt="-d"
          shift;;
      -x) opt="-x"
          shift;;
      -a) all=x
          shift;;
      *)  break;;
    esac
  done
  local file="$1"
  shift
  if [[ "$file" = /* ]]; then
    echo "$file"
  else
    for d in "$@"; do
      if [ $opt "$d/$file" ]; then
        echo "$d/$file"
        if [ -z "$all" ]; then
          return
        fi
      fi
    done
  fi
}

productDirs() {
  local p="$PRODUCTDIR"
  eval "$1=( )"

  while true; do
    eval "$1=( \"\$p\" \"\${$1[@]}\" )"
    if [ "$p" = "$ROOTPRODUCTDIR" ]; then
      return
    fi
    p="$(dirname "$(dirname "$p")")"
  done
}

lookupFile() {
  local dirs=( )
  productDirs dirs
  lookupFileIn "$@" "$GENDIR" "${dirs[@]}" "$CURRENT" "$ROOT" "$SOW"
}

lookupPlugin() {
  local dirs=( )
  productDirs dirs
  lookupFileIn -x "plugins/$1/plugin" "${dirs[@]}" "$CURRENT" "$ROOT" "$SOW"
}

lookupStub() {
  local dirs=( )
  if isInternet "$1"; then
    if  curl -sfI "$1" >/dev/null; then
      echo "$1"
    fi
    return
  fi
  productDirs dirs
  lookupFileIn "$1" "${dirs[@]}" "$CURRENT"  "$ROOT" "$SOW"
}

setStubs() {
  local dirs=( )
  productDirs dirs
  while IFS= read -r line; do 
    eval $1="( \"\$line\" \"\${$1[@]}\" )"
  done <<<"$(lookupFileIn -a "$2" "${dirs[@]}" "$CURRENT" "$ROOT" "$SOW")"
}

################################################################################
# standard plugin utilities
################################################################################

PLUGIN_setup()
{
  if [ -z "$PLUGININSTANCE" ]; then
    PLUGININSTANCE="${1:-${2:-$PLUGINNAME}}"
  fi

  if [ -n "$DEPLOYMEMT" ]; then
    SETTINGSJSON="$(cat "$DEPLOYMEMT")"
  fi
  if [ -z "$PLUGINCONFIG" ]; then
    PLUGINCONFIGJSON="{}"
  else
    PLUGINCONFIGJSON="$(cat "$PLUGINCONFIG")"
  fi


  dir="$GENDIR/$PLUGININSTANCE"
  state="$STATEDIR/$PLUGININSTANCE"
  mkdir -p "$dir" "$state"

  verbose "using path $PLUGININSTANCE"
}

killpg()
{
  local s
  case "$1" in
  -*) s="$1"; shift;;
  esac

  local g="$(ps -o pgid= $1)"
  if [ -n "${g## }" ]; then
    kill $s -- -${g## }
  fi
}

isInternet()
{
  [ "${1#https://}" != "$1" -o "${1#http://}" != "$1" ]
}

sha1()
{
  sha1sum <<< "$1" | (
    read a b
    echo "$a"
  )
}