tools

#!/bin/bash

function create_docker_network () {
	set -e
  print_usage()
  {
    printf "usage: create_docker_network --env-file=my-env-file --pretty-print --debug"
  }

  env_files=()
  while [ $# -gt 0 ]; do
    case "$1" in
      --env-file*)
        env_files+=("${1#*=}")
        ;;
      --pretty-print)
        pretty_print=1
        ;;
      --debug)
        debug=1
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  # if [ -z "$env_files" ]; then
  #   print_usage
  #   exit 1
  # fi

  for i in "${env_files[@]}"
  do
    eval $(cat $i)
  done

  if [ -z "$KIND_CLUSTER_NAME" ]; then
    echo "${FUNCNAME[0]} - environment var named KIND_CLUSTER_NAME is required" && exit 1
  fi

  if [ -z "$NETWORK_PREFIX" ]; then
    echo "environment var named NETWORK_PREFIX is required" && exit 1
  fi

  if [ -z "$NETWORK_CIDR" ]; then
    NETWORK_CIDR=${NETWORK_PREFIX}.0.0/16
  fi

  if [ -z "$NETWORK_GATEWAY" ]; then
    NETWORK_GATEWAY=${NETWORK_PREFIX}.0.1
  fi

	if [[ -z "$(docker network ls --filter "name=^${KIND_CLUSTER_NAME}$" -q)" ]]; then
    # sleep 20
    command=$(cat <<EOF
		docker network create \
			--scope local \
			--driver bridge \
			--subnet ${NETWORK_CIDR} \
			--gateway $NETWORK_GATEWAY \
			$KIND_CLUSTER_NAME
EOF
)
    if [[ -n "$debug" ]]; then print_info --type=command --text="$command"; fi
    output=$(eval "$command")
    if [[ -n "$pretty_print" ]]; then print_info --type=output --text="$output"; fi
	fi
}
# https://kind.sigs.k8s.io/docs/user/configuration/
function create_kind () {
	set -e
  print_usage()
  {
    printf "usage: create_kind --env-file=my-env-file --pretty-print --debug"
  }

  env_files=()
  while [ $# -gt 0 ]; do
    case "$1" in
      --env-file*)
        env_files+=("${1#*=}")
        ;;
      --pretty-print)
        pretty_print=1
        ;;
      --debug)
        debug=1
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  # if [ -z "$env_files" ]; then
  #   print_usage
  #   exit 1
  # fi

  for i in "${env_files[@]}"
  do
    eval $(cat $i)
  done

  if [ -z "$KIND_CLUSTER_NAME" ]; then
    echo "${FUNCNAME[0]} - environment var named KIND_CLUSTER_NAME is required" && exit 1
  fi

  if [ -z "$KIND_CLUSTER_IMAGE" ]; then
    echo "environment var named KIND_CLUSTER_IMAGE is required" && exit 1
  fi

  if [ -z "$KIND_CONFIG_FILE" ]; then
    KIND_CONFIG_FILE=kind-config.yaml
  fi

  print_info --type=warning --text="wait docker network ${KIND_CLUSTER_NAME} start ..."
  until [[ -n $KIND_EXPERIMENTAL_DOCKER_NETWORK ]]
  do
    KIND_EXPERIMENTAL_DOCKER_NETWORK=$(docker network ls --filter "name=^${KIND_CLUSTER_NAME}$" -q --format '{{ .Name }}')
    sleep 2
  done

	if [[ -z "$(kind get clusters 2>/dev/null|sed -rn '/^'${KIND_CLUSTER_NAME}'$/p')" ]]; then
    command=$(cat <<EOF
    export KIND_EXPERIMENTAL_DOCKER_NETWORK=${KIND_EXPERIMENTAL_DOCKER_NETWORK}
		kind create cluster \
			--name ${KIND_CLUSTER_NAME} \
			--config ${KIND_CONFIG_FILE} \
			--image ${KIND_CLUSTER_IMAGE}
EOF
)
  # -v 6
    if [[ -n "$debug" ]]; then print_info --type=command --text="$command"; fi
    output=$(eval "$command")
    if [[ -n "$pretty_print" ]]; then print_info --type=output --text="$output"; fi
	fi
}

function delete_kind () {
	set +e
  print_usage()
  {
    printf "usage: delete_kind --env-file=my-env-file"
  }

  env_files=()
  while [ $# -gt 0 ]; do
    case "$1" in
      --env-file*)
        env_files+=("${1#*=}")
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  # if [ -z "$env_files" ]; then
  #   print_usage
  #   exit 1
  # fi

  for i in "${env_files[@]}"
  do
    eval $(cat $i)
  done

  if [ -z "$KIND_CLUSTER_NAME" ]; then
    echo "${FUNCNAME[0]} - environment var named KIND_CLUSTER_NAME is required" && exit 1
  fi

  kind delete cluster --name ${KIND_CLUSTER_NAME}
	docker network rm ${KIND_CLUSTER_NAME}
}

function start_cluster () {
  set -e
  print_usage()
  {
    printf "usage: start_cluster --env-file=my-env-file"
  }

  env_files=()
  while [ $# -gt 0 ]; do
    case "$1" in
      --env-file*)
        env_files+=("${1#*=}")
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  # if [ -z "$env_files" ]; then
  #   print_usage
  #   exit 1
  # fi

  for i in "${env_files[@]}"
  do
    eval $(cat $i)
  done

  if [ -z "$KIND_CLUSTER_NAME" ]; then
    echo "${FUNCNAME[0]} - environment var named KIND_CLUSTER_NAME is required" && exit 1
  fi
  nodes=$(kind get nodes --name ${KIND_CLUSTER_NAME})
  for node in $nodes; do
    if ! docker ps --format '{{.Names}}' | grep -w $node &> /dev/null; then
      sh -c "docker start $node" &> /dev/null
    fi
  done
}

function stop_cluster () {
  set -e
  print_usage()
  {
    printf "usage: stop_cluster --env-file=my-env-file"
  }

  env_files=()
  while [ $# -gt 0 ]; do
    case "$1" in
      --env-file*)
        env_files+=("${1#*=}")
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  # if [ -z "$env_files" ]; then
  #   print_usage
  #   exit 1
  # fi

  for i in "${env_files[@]}"
  do
    eval $(cat $i)
  done

  if [ -z "$KIND_CLUSTER_NAME" ]; then
    echo "${FUNCNAME[0]} - environment var named KIND_CLUSTER_NAME is required" && exit 1
  fi
  nodes=$(kind get nodes --name ${KIND_CLUSTER_NAME})
  for node in $nodes; do
    if docker ps --format '{{.Names}}' | grep -w $node &> /dev/null; then
      sh -c "docker stop $node" &> /dev/null
    fi
  done
}

function wait_cluster () {
	set -e
  print_usage()
  {
    printf "usage: wait_cluster --env-file=my-env-file"
  }

  env_files=()
  while [ $# -gt 0 ]; do
    case "$1" in
      --env-file*)
        env_files+=("${1#*=}")
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  # if [ -z "$env_files" ]; then
  #   print_usage
  #   exit 1
  # fi

  for i in "${env_files[@]}"
  do
    eval $(cat $i)
  done

  set -e
  if [ -z "$KIND_CLUSTER_NAME" ]; then
    echo "${FUNCNAME[0]} - environment var named KIND_CLUSTER_NAME is required" && exit 1
  fi

  if [ -z "$KUBE_CONTEXT" ]; then
    echo "environment var named KUBE_CONTEXT is required" && exit 1
  fi

  cluster=$(kind get clusters 2>/dev/null|sed -rn '/^'${KIND_CLUSTER_NAME}'$/p')
  until [[ -n $cluster ]]
  do
    sleep $(shuf -i 5-10 -n 1)
    cluster=$(kind get clusters 2>/dev/null|sed -rn '/^'${KIND_CLUSTER_NAME}'$/p')
  done

  start_cluster
  controls_planes=$(kind get nodes --name ${KIND_CLUSTER_NAME}|sed -rn '/-control-plane$/p'|tr '\n' ' '|sed 's/,$//')
  for control_plane in $controls_planes; do
    HostPort=$(docker inspect $control_plane|jq -r '.[].NetworkSettings.Ports["6443/tcp"][0].HostPort')
    HostIp=$(docker inspect $control_plane|jq -r '.[].NetworkSettings.Ports["6443/tcp"][0].HostIp')
    while ! timeout 1 bash -c "echo > /dev/tcp/$HostIp/$HostPort"; do   
      sleep $(shuf -i 1-5 -n 1) # wait for 1-5 seconds before check again
    done
  done
  # kind export kubeconfig --name $KIND_CLUSTER_NAME

  set +e
  kubectl get nodes --context ${KUBE_CONTEXT} &>/dev/null
  return_code=$?
  until [[ $return_code -eq 0 ]]
  do
    sleep $(shuf -i 5-10 -n 1)
    kubectl get nodes --context ${KUBE_CONTEXT} &>/dev/null
    return_code=$?
  done
  set -e

  until [[ -n $cluster_ready ]]
  do
    status=$(kubectl get nodes --context ${KUBE_CONTEXT} -o jsonpath='{..status.conditions[?(@.type=="Ready")].status}')
    error=0
    for s in $status; do
      if [[ "$s" != "True" ]]; then
        error=1
      fi
    done
    if [[ "$error" == "0" ]]; then
      cluster_ready=1
    else
      sleep $(shuf -i 5-10 -n 1)
    fi
  done
}

function submodule_update () {
  set -e
  for m in modules/*; do
    git submodule update $m
    cd $m
    branch=$(git rev-parse --abbrev-ref HEAD)
    if [[ -z "$branch" ]] || [[ $branch == "HEAD" ]]; then
      unset branch
      commit=$(git rev-parse HEAD)
      git fetch --quiet
      branches=$(git branch --no-color --no-column --format "%(refname:lstrip=2)" --contains $commit|cat|sed '/HEAD/d'|sed -r '/^\s*$/d')
      nb=$(echo "$branches" |wc -l)
      if [[ -z "$branches" ]]; then
        git fetch --all --quiet
        branches=$(git branch -a --no-color --no-column --format "%(refname:lstrip=3)" --contains $commit|cat|sed '/HEAD/d'|sed -r '/^\s*$/d')
        nb=$(echo "$branches" |wc -l)
      fi

      if [[ $nb -eq 0 ]]; then
        echo "Error on submodule $m : no branches found"
        exit 1
      elif [[ $nb -eq 1 ]]; then
        branch=$branches
      else
        echo "Error on submodule $m : found $nb branch(es): "$branches
        exit 1
      fi
            
      git fetch origin $branch:$branch
      git checkout --quiet ${branch}
    fi
    echo "$m : $branch" 
    cd $OLDPWD
  done
}

function docker_build () {
  set -e

  print_usage()
  {
    printf "usage: docker_build --env-file=my-env-file"
  }

  env_files=()
  while [ $# -gt 0 ]; do
    case "$1" in
      --env-file*)
        env_files+=("${1#*=}")
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  # if [ -z "$env_files" ]; then
  #   print_usage
  #   exit 1
  # fi

  for i in "${env_files[@]}"
  do
    eval $(cat $i)
    if [[ -n "$(sed -rn '/^KIND_CLUSTER_NAME=/p' $i)" ]]; then
      print_info --type=warning --text="wait kind cluster ${KIND_CLUSTER_NAME} start ..."
      wait_cluster
    fi
  done

  if [ -z "$DOCKER_BUILD_REPOSITORY" ]; then
    echo "environment var named DOCKER_BUILD_REPOSITORY is required" && exit 1
  fi

  if [ -z "$DOCKER_BUILD_TAG" ]; then
    echo "environment var named DOCKER_BUILD_TAG is required" && exit 1
  fi

  if [ -z "$DOCKER_BUILD_DOCKERFILE" ]; then
    echo "environment var named DOCKER_BUILD_DOCKERFILE is required" && exit 1
  fi

  if [ -z "$DOCKER_BUILD_CONTEXT" ]; then
    echo "environment var named DOCKER_BUILD_CONTEXT is required" && exit 1
  fi

  set -x
  DOCKER_BUILDKIT=1 docker build \
    ${DOCKER_BUILD_TARGET:+--target=$DOCKER_BUILD_TARGET} \
    --build-arg BUILDKIT_INLINE_CACHE=1 \
    ${DOCKER_BUILD_ARG_01:+--build-arg $DOCKER_BUILD_ARG_01} \
    ${DOCKER_BUILD_ARG_02:+--build-arg $DOCKER_BUILD_ARG_02} \
    ${DOCKER_BUILD_ARG_03:+--build-arg $DOCKER_BUILD_ARG_03} \
    ${DOCKER_BUILD_ARG_04:+--build-arg $DOCKER_BUILD_ARG_04} \
    ${DOCKER_BUILD_ARG_05:+--build-arg $DOCKER_BUILD_ARG_05} \
    ${DOCKER_BUILD_ARG_06:+--build-arg $DOCKER_BUILD_ARG_06} \
    ${DOCKER_BUILD_ARG_07:+--build-arg $DOCKER_BUILD_ARG_07} \
    ${DOCKER_BUILD_ARG_08:+--build-arg $DOCKER_BUILD_ARG_08} \
    ${DOCKER_BUILD_ARG_09:+--build-arg $DOCKER_BUILD_ARG_09} \
    ${DOCKER_BUILD_ARG_10:+--build-arg $DOCKER_BUILD_ARG_10} \
    ${DOCKER_BUILD_ARG_11:+--build-arg $DOCKER_BUILD_ARG_11} \
    ${DOCKER_BUILD_ARG_12:+--build-arg $DOCKER_BUILD_ARG_12} \
    ${DOCKER_BUILD_ARG_13:+--build-arg $DOCKER_BUILD_ARG_13} \
    ${DOCKER_BUILD_ARG_14:+--build-arg $DOCKER_BUILD_ARG_14} \
    ${DOCKER_BUILD_ARG_15:+--build-arg $DOCKER_BUILD_ARG_15} \
    ${DOCKER_BUILD_ARG_16:+--build-arg $DOCKER_BUILD_ARG_16} \
    ${DOCKER_BUILD_ARG_17:+--build-arg $DOCKER_BUILD_ARG_17} \
    ${DOCKER_BUILD_ARG_18:+--build-arg $DOCKER_BUILD_ARG_18} \
    ${DOCKER_BUILD_ARG_19:+--build-arg $DOCKER_BUILD_ARG_19} \
    ${DOCKER_BUILD_ARG_20:+--build-arg $DOCKER_BUILD_ARG_20} \
    ${DOCKER_BUILD_SECRET_01:+--secret $DOCKER_BUILD_SECRET_01} \
    ${DOCKER_BUILD_SECRET_02:+--secret $DOCKER_BUILD_SECRET_02} \
    ${DOCKER_BUILD_SECRET_03:+--secret $DOCKER_BUILD_SECRET_03} \
    ${DOCKER_BUILD_SECRET_04:+--secret $DOCKER_BUILD_SECRET_04} \
    ${DOCKER_BUILD_SECRET_05:+--secret $DOCKER_BUILD_SECRET_05} \
    ${DOCKER_BUILD_SECRET_06:+--secret $DOCKER_BUILD_SECRET_06} \
    ${DOCKER_BUILD_SECRET_07:+--secret $DOCKER_BUILD_SECRET_07} \
    ${DOCKER_BUILD_SECRET_08:+--secret $DOCKER_BUILD_SECRET_08} \
    ${DOCKER_BUILD_SECRET_09:+--secret $DOCKER_BUILD_SECRET_09} \
    ${DOCKER_BUILD_SECRET_10:+--secret $DOCKER_BUILD_SECRET_10} \
    ${DOCKER_BUILD_SECRET_11:+--secret $DOCKER_BUILD_SECRET_11} \
    ${DOCKER_BUILD_SECRET_12:+--secret $DOCKER_BUILD_SECRET_12} \
    ${DOCKER_BUILD_SECRET_13:+--secret $DOCKER_BUILD_SECRET_13} \
    ${DOCKER_BUILD_SECRET_14:+--secret $DOCKER_BUILD_SECRET_14} \
    ${DOCKER_BUILD_SECRET_15:+--secret $DOCKER_BUILD_SECRET_15} \
    ${DOCKER_BUILD_SECRET_16:+--secret $DOCKER_BUILD_SECRET_16} \
    ${DOCKER_BUILD_SECRET_17:+--secret $DOCKER_BUILD_SECRET_17} \
    ${DOCKER_BUILD_SECRET_18:+--secret $DOCKER_BUILD_SECRET_18} \
    ${DOCKER_BUILD_SECRET_19:+--secret $DOCKER_BUILD_SECRET_19} \
    ${DOCKER_BUILD_SECRET_20:+--secret $DOCKER_BUILD_SECRET_20} \
    --cache-from $DOCKER_BUILD_REPOSITORY:latest \
    --tag $DOCKER_BUILD_REPOSITORY:$DOCKER_BUILD_TAG \
    --file $DOCKER_BUILD_DOCKERFILE \
    --compress \
    $DOCKER_BUILD_CONTEXT
  docker tag $DOCKER_BUILD_REPOSITORY:$DOCKER_BUILD_TAG $DOCKER_BUILD_REPOSITORY:latest
  set +x
}

function push_images () {
  set -e

  print_usage()
  {
    printf "usage: push_images --env-file=my-env-file"
  }

  env_files=()
  while [ $# -gt 0 ]; do
    case "$1" in
      --env-file*)
        env_files+=("${1#*=}")
        ;;
      --pretty-print)
        pretty_print=1
        ;;
      --debug)
        debug=1
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  # if [ -z "$env_files" ]; then
  #   print_usage
  #   exit 1
  # fi

  for i in "${env_files[@]}"
  do
    eval $(cat $i)
    if [[ -n "$(sed -rn '/^KIND_CLUSTER_NAME=/p' $i)" ]]; then
      print_info --type=warning --text="push_images - wait kind cluster ${KIND_CLUSTER_NAME} start ..."
      wait_cluster
    fi
  done

  if [ -z "$DOCKER_BUILD_REPOSITORY" ]; then
    echo "environment var named DOCKER_BUILD_REPOSITORY is required" && exit 1
  fi

  if [ -z "$DOCKER_BUILD_TAG" ]; then
    echo "environment var named DOCKER_BUILD_TAG is required" && exit 1
  fi

  if [ -z "$KIND_CLUSTER_NAME" ]; then
    echo "${FUNCNAME[0]} - environment var named KIND_CLUSTER_NAME is required" && exit 1
  fi

  if [ -z "$KIND_NODES" ]; then
    echo "environment var named KIND_NODES is required" && exit 1
  fi

  IMAGE_ID=$(docker inspect ${DOCKER_BUILD_REPOSITORY}:${DOCKER_BUILD_TAG} --format='{{.Id}}')

  # if [[ -n "$debug" ]]; then
    jo \
      KIND_CLUSTER_NAME=$KIND_CLUSTER_NAME \
      KIND_NODES="$KIND_NODES" \
      DOCKER_BUILD_REPOSITORY=$DOCKER_BUILD_REPOSITORY \
      DOCKER_BUILD_TAG=$DOCKER_BUILD_TAG \
      IMAGE_ID=$IMAGE_ID|yq e -P
    echo
  # fi

  for i in $KIND_NODES
  do
    # docker exec -it $i ctr --namespace=k8s.io image ls
    command='images=$(docker exec $i crictl image --no-trunc); echo "$images"|sed -n 1p; echo "$images"|sed -n "/^${DOCKER_BUILD_REPOSITORY//\//\\/}\s/p"'
    if [[ -n "$debug" ]]; then print_info --type=command --text="$command"; fi
    output=$(eval "$command")
    if [[ -n "$pretty_print" ]]; then print_info --type=output --text="$output"; fi

    command="docker exec $i crictl inspecti --output go-template --template '{{.status.id}}' $IMAGE_ID"
    if [[ -n "$debug" ]]; then print_info --type=command --text="$command"; fi
    set +e
    # output=$(set +e && eval "$command")
    output=$(eval "$command")
    return_code=$?
    set -e
    # if [[ -n "$pretty_print" ]]; then print_info --type=warning --text="$output"; fi
    if [[ $return_code -ne 0 ]]; then
      print_info --type=warning --text="no such image $IMAGE_ID present on $i"
      command="kind load docker-image ${DOCKER_BUILD_REPOSITORY}:${DOCKER_BUILD_TAG} --name ${KIND_CLUSTER_NAME} --nodes $i"
      if [[ -n "$debug" ]]; then print_info --type=command --text="$command"; fi
      output=$(eval "$command")
      if [[ -n "$pretty_print" ]]; then print_info --type=output --text="$output"; fi

      command='images=$(docker exec $i crictl image --no-trunc); echo "$images"|sed -n 1p; echo "$images"|sed -n "/^${DOCKER_BUILD_REPOSITORY//\//\\/}\s/p"'
      if [[ -n "$debug" ]]; then print_info --type=command --text="$command"; fi
      output=$(eval "$command")
      if [[ -n "$pretty_print" ]]; then print_info --type=output --text="$output"; fi
    else
      print_info --type=warning --text="image $IMAGE_ID present on $i"
      command="docker exec $i ctr --namespace=k8s.io images tag $IMAGE_ID ${DOCKER_BUILD_REPOSITORY}:${DOCKER_BUILD_TAG} 2>/dev/null"
      if [[ -n "$debug" ]]; then print_info --type=command --text="$command"; fi
      set +e
      output=$(eval "$command")
      # output=$(set +e && eval "$command")
      set -e
      if [[ -n "$pretty_print" ]]; then print_info --type=output --text="$output"; fi
    fi
    # docker exec -it $i crictl rmi $IMAGE_ID
  done
}

function print_info () {
  set -e
  red='\033[1;31m'; blue='\033[34m'; yellow='\033[33m'; reset='\033[0m'

  print_usage()
  {
    printf "usage: print_info --type=command --text=text"
  }

  while [ $# -gt 0 ]; do
    case "$1" in
      --type*)
        type="${1#*=}"
        ;;
      --text*)
        text="${1#*=}"
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  if [[ $type == "command" ]]; then
    printf "$red%s$reset\n\n" "$(echo $text | sed ':a;N;$!ba;s#\\\n##g')"
  elif [[ $type == "output" ]]; then
    printf "$blue%s$reset\n\n" "${text}"
  elif [[ $type == "warning" ]]; then
    printf "$yellow%s$reset\n\n" "${text}"
  fi
}

function crictl_images () {
  set -e

  print_usage()
  {
    printf "usage: crictl_images --env-file=my-env-file"
  }

  env_files=()
  while [ $# -gt 0 ]; do
    case "$1" in
      --env-file*)
        env_files+=("${1#*=}")
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  # if [ -z "$env_files" ]; then
  #   print_usage
  #   exit 1
  # fi

  for i in "${env_files[@]}"
  do
    eval $(cat $i)
    if [[ -n "$(sed -rn '/^KIND_CLUSTER_NAME=/p' $i)" ]]; then
      print_info --type=warning --text="crictl_images - wait kind cluster ${KIND_CLUSTER_NAME} start ..."
      wait_cluster
    fi
  done

  if [ -z "$KIND_CLUSTER_NAME" ]; then
    echo "${FUNCNAME[0]} - environment var named KIND_CLUSTER_NAME is required" && exit 1
  fi

  if [ -z "$KIND_NODES" ]; then
    echo "environment var named KIND_NODES is required" && exit 1
  fi

  for i in $KIND_NODES
  do
    docker exec $i crictl images
  done
}

function helm_repo_add () {
  set -e

  print_usage()
  {
    printf "usage: helm_repo_add --env-file=my-env-file --pretty-print --debug"
  }

  env_files=()
  while [ $# -gt 0 ]; do
    case "$1" in
      --env-file*)
        env_files+=("${1#*=}")
        ;;
      --pretty-print)
        pretty_print=1
        ;;
      --debug)
        debug=1
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  # if [ -z "$env_files" ]; then
  #   print_usage
  #   exit 1
  # fi

  for i in "${env_files[@]}"
  do
    eval $(cat $i)
  done

  if [ -z "$HELM_REPO_NAME" ]; then
    echo "environment var named HELM_REPO_NAME is required" && exit 1
  fi

  if [ -z "$HELM_REPO_URL" ]; then
    echo "environment var named HELM_REPO_URL is required" && exit 1
  fi

command=$(cat <<EOF
    helm repo add --force-update $HELM_REPO_NAME $HELM_REPO_URL
EOF
)

  if [[ -n "$debug" ]]; then print_info --type=command --text="$command"; fi
  output=$(eval "$command")
  if [[ -n "$pretty_print" ]]; then print_info --type=output --text="$output"; fi
}

function pull_push_images () {
  set -e

  print_usage()
  {
    printf "usage: pull_push_images --env-file=my-env-file --pretty-print --debug"
  }

  env_files=()
  while [ $# -gt 0 ]; do
    case "$1" in
      --env-file*)
        env_files+=("${1#*=}")
        ;;
      --pretty-print)
        pretty_print=1
        ;;
      --debug)
        debug=1
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  # if [ -z "$env_files" ]; then
  #   print_usage
  #   exit 1
  # fi

  for i in "${env_files[@]}"
  do
    eval $(cat $i)
    if [[ -n "$(sed -rn '/^KIND_CLUSTER_NAME=/p' $i)" ]]; then
      print_info --type=warning --text="pull_push_images - wait kind cluster ${KIND_CLUSTER_NAME} start ..."
      wait_cluster
    fi
  done

  args=
  for i in "${env_files[@]}"
  do 
    args="$args $(echo -n '--env-file='$i)"
  done

  images=$(helm_template $args|sed -rn '/\s+image:\s+"?[a-zA-Z0-9\./:-]+.*/p'|sed -r 's#\s+image:\s+"?([a-zA-Z0-9\./:-]+).*#\1#'|sort -u)
  for image in $images; do \
    command="docker pull $image"
    if [[ -n "$debug" ]]; then echo -e "\e[1;31m$command\e[0m"; fi
    echo -e "\e[1;34m"
    docker pull $image
    echo -e "\e[0m";
    tempfile_envfile=$(mktemp /tmp/envfile.XXXXXXXXXX)
    trap "rm -Rf $tempfile_envfile" 0 2 3 15
    echo "DOCKER_BUILD_REPOSITORY=$(echo $image|cut -d':' -f1)" >> $tempfile_envfile
    echo "DOCKER_BUILD_TAG=$(echo $image|cut -d':' -f2)" >> $tempfile_envfile
    push_images $args --env-file=$tempfile_envfile ${pretty_print:+--pretty-print} ${debug:+--debug}
	done

}

function helm_template () {
  set -e

  print_usage()
  {
    printf "usage: helm_template --env-file=my-env-file --pretty-print --debug"
  }

  env_files=()
  while [ $# -gt 0 ]; do
    case "$1" in
      --env-file*)
        env_files+=("${1#*=}")
        ;;
      --pretty-print)
        pretty_print=1
        ;;
      --debug)
        debug=1
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  # if [ -z "$env_files" ]; then
  #   print_usage
  #   exit 1
  # fi

  for i in "${env_files[@]}"
  do
    eval $(cat $i)
    if [[ -n "$(sed -rn '/^KIND_CLUSTER_NAME=/p' $i)" ]]; then
      print_info --type=warning --text="helm_template - wait kind cluster ${KIND_CLUSTER_NAME} start ..."
      wait_cluster
    fi
  done

  if [ -z "$KUBE_CONTEXT" ]; then
    echo "environment var named KUBE_CONTEXT is required" && exit 1
  fi

  if [ -z "$HELM_RELEASE" ]; then
    echo "environment var named HELM_RELEASE is required" && exit 1
  fi

  if [ -z "$HELM_CHART" ]; then
    echo "environment var named HELM_CHART is required" && exit 1
  fi

  if [ -z "$HELM_NAMESPACE" ]; then
    echo "environment var named HELM_NAMESPACE is required" && exit 1
  fi

  # --validate \
  command=$(cat <<EOF
    helm template \
		--kube-context $KUBE_CONTEXT \
    --namespace ${HELM_NAMESPACE} \
    ${HELM_VERSION:+--version $HELM_VERSION} \
    ${HELM_VALUES_01:+--values $HELM_VALUES_01} \
    ${HELM_VALUES_02:+--values $HELM_VALUES_02} \
    ${HELM_VALUES_03:+--values $HELM_VALUES_03} \
    ${HELM_VALUES_04:+--values $HELM_VALUES_04} \
    ${HELM_VALUES_05:+--values $HELM_VALUES_05} \
    ${HELM_VALUES_06:+--values $HELM_VALUES_06} \
    ${HELM_VALUES_07:+--values $HELM_VALUES_07} \
    ${HELM_VALUES_08:+--values $HELM_VALUES_08} \
    ${HELM_VALUES_09:+--values $HELM_VALUES_09} \
    ${HELM_VALUES_10:+--values $HELM_VALUES_10} \
    ${HELM_VALUES_11:+--values $HELM_VALUES_11} \
    ${HELM_VALUES_12:+--values $HELM_VALUES_12} \
    ${HELM_VALUES_13:+--values $HELM_VALUES_13} \
    ${HELM_VALUES_14:+--values $HELM_VALUES_14} \
    ${HELM_VALUES_15:+--values $HELM_VALUES_15} \
    ${HELM_VALUES_16:+--values $HELM_VALUES_16} \
    ${HELM_VALUES_17:+--values $HELM_VALUES_17} \
    ${HELM_VALUES_18:+--values $HELM_VALUES_18} \
    ${HELM_VALUES_19:+--values $HELM_VALUES_19} \
    ${HELM_VALUES_20:+--values $HELM_VALUES_20} \
    ${HELM_SET_01:+--set $HELM_SET_01} \
    ${HELM_SET_02:+--set $HELM_SET_02} \
    ${HELM_SET_03:+--set $HELM_SET_03} \
    ${HELM_SET_04:+--set $HELM_SET_04} \
    ${HELM_SET_05:+--set $HELM_SET_05} \
    ${HELM_SET_06:+--set $HELM_SET_06} \
    ${HELM_SET_07:+--set $HELM_SET_07} \
    ${HELM_SET_08:+--set $HELM_SET_08} \
    ${HELM_SET_09:+--set $HELM_SET_09} \
    ${HELM_SET_10:+--set $HELM_SET_10} \
    ${HELM_SET_11:+--set $HELM_SET_11} \
    ${HELM_SET_12:+--set $HELM_SET_12} \
    ${HELM_SET_13:+--set $HELM_SET_13} \
    ${HELM_SET_14:+--set $HELM_SET_14} \
    ${HELM_SET_15:+--set $HELM_SET_15} \
    ${HELM_SET_16:+--set $HELM_SET_16} \
    ${HELM_SET_17:+--set $HELM_SET_17} \
    ${HELM_SET_18:+--set $HELM_SET_18} \
    ${HELM_SET_19:+--set $HELM_SET_19} \
    ${HELM_SET_20:+--set $HELM_SET_20} \
    ${HELM_SET_STRING_01:+--set-string $HELM_SET_STRING_01} \
    ${HELM_SET_STRING_02:+--set-string $HELM_SET_STRING_02} \
    ${HELM_SET_STRING_03:+--set-string $HELM_SET_STRING_03} \
    ${HELM_SET_STRING_04:+--set-string $HELM_SET_STRING_04} \
    ${HELM_SET_STRING_05:+--set-string $HELM_SET_STRING_05} \
    ${HELM_SET_STRING_06:+--set-string $HELM_SET_STRING_06} \
    ${HELM_SET_STRING_07:+--set-string $HELM_SET_STRING_07} \
    ${HELM_SET_STRING_08:+--set-string $HELM_SET_STRING_08} \
    ${HELM_SET_STRING_09:+--set-string $HELM_SET_STRING_09} \
    ${HELM_SET_STRING_10:+--set-string $HELM_SET_STRING_10} \
    ${HELM_SET_STRING_11:+--set-string $HELM_SET_STRING_11} \
    ${HELM_SET_STRING_12:+--set-string $HELM_SET_STRING_12} \
    ${HELM_SET_STRING_13:+--set-string $HELM_SET_STRING_13} \
    ${HELM_SET_STRING_14:+--set-string $HELM_SET_STRING_14} \
    ${HELM_SET_STRING_15:+--set-string $HELM_SET_STRING_15} \
    ${HELM_SET_STRING_16:+--set-string $HELM_SET_STRING_16} \
    ${HELM_SET_STRING_17:+--set-string $HELM_SET_STRING_17} \
    ${HELM_SET_STRING_18:+--set-string $HELM_SET_STRING_18} \
    ${HELM_SET_STRING_19:+--set-string $HELM_SET_STRING_19} \
    ${HELM_SET_STRING_20:+--set-string $HELM_SET_STRING_20} \
		--name-template=${HELM_RELEASE} \
    ${HELM_CHART}
EOF
)
  
  if [[ -n "$debug" ]]; then echo -e "\e[1;31m$(echo $command | sed ':a;N;$!ba;s#\\\n##g')\e[0m"; fi
  output=$(eval "$command")
  echo "$output"|yq eval -P
}

function helm_upgrade () {
  set -e

  print_usage()
  {
    printf "usage: helm_upgrade --env-file=my-env-file --debug"
  }

  env_files=()
  while [ $# -gt 0 ]; do
    case "$1" in
      --env-file*)
        env_files+=("${1#*=}")
        ;;
      --debug)
        debug=1
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  # if [ -z "$env_files" ]; then
  #   print_usage
  #   exit 1
  # fi

  for i in "${env_files[@]}"
  do
    eval $(cat $i)
    if [[ -n "$(sed -rn '/^KIND_CLUSTER_NAME=/p' $i)" ]]; then
      print_info --type=warning --text="helm_upgrade - wait kind cluster ${KIND_CLUSTER_NAME} start ..."
      wait_cluster
    fi
  done

  if [ -z "$KUBE_CONTEXT" ]; then
    echo "environment var named KUBE_CONTEXT is required" && exit 1
  fi

  if [ -z "$HELM_NAMESPACE" ]; then
    echo "environment var named HELM_NAMESPACE is required" && exit 1
  fi

  if [ -z "$HELM_RELEASE" ]; then
    echo "environment var named HELM_RELEASE is required" && exit 1
  fi

  if [ -z "$HELM_CHART" ]; then
    echo "environment var named HELM_CHART is required" && exit 1
  fi

  command=$(cat <<EOF
	helm upgrade \
		--kube-context $KUBE_CONTEXT \
		--install \
    ${HELM_WAIT:+--wait} \
    ${HELM_TIMEOUT:+--timeout $HELM_TIMEOUT} \
		--create-namespace \
		--namespace ${HELM_NAMESPACE} \
    ${HELM_REUSE_VALUES:+--reuse-values} \
    ${HELM_VERSION:+--version $HELM_VERSION} \
    ${HELM_VALUES_01:+--values $HELM_VALUES_01} \
    ${HELM_VALUES_02:+--values $HELM_VALUES_02} \
    ${HELM_VALUES_03:+--values $HELM_VALUES_03} \
    ${HELM_VALUES_04:+--values $HELM_VALUES_04} \
    ${HELM_VALUES_05:+--values $HELM_VALUES_05} \
    ${HELM_VALUES_06:+--values $HELM_VALUES_06} \
    ${HELM_VALUES_07:+--values $HELM_VALUES_07} \
    ${HELM_VALUES_08:+--values $HELM_VALUES_08} \
    ${HELM_VALUES_09:+--values $HELM_VALUES_09} \
    ${HELM_VALUES_10:+--values $HELM_VALUES_10} \
    ${HELM_VALUES_11:+--values $HELM_VALUES_11} \
    ${HELM_VALUES_12:+--values $HELM_VALUES_12} \
    ${HELM_VALUES_13:+--values $HELM_VALUES_13} \
    ${HELM_VALUES_14:+--values $HELM_VALUES_14} \
    ${HELM_VALUES_15:+--values $HELM_VALUES_15} \
    ${HELM_VALUES_16:+--values $HELM_VALUES_16} \
    ${HELM_VALUES_17:+--values $HELM_VALUES_17} \
    ${HELM_VALUES_18:+--values $HELM_VALUES_18} \
    ${HELM_VALUES_19:+--values $HELM_VALUES_19} \
    ${HELM_VALUES_20:+--values $HELM_VALUES_20} \
    ${HELM_SET_01:+--set $HELM_SET_01} \
    ${HELM_SET_02:+--set $HELM_SET_02} \
    ${HELM_SET_03:+--set $HELM_SET_03} \
    ${HELM_SET_04:+--set $HELM_SET_04} \
    ${HELM_SET_05:+--set $HELM_SET_05} \
    ${HELM_SET_06:+--set $HELM_SET_06} \
    ${HELM_SET_07:+--set $HELM_SET_07} \
    ${HELM_SET_08:+--set $HELM_SET_08} \
    ${HELM_SET_09:+--set $HELM_SET_09} \
    ${HELM_SET_10:+--set $HELM_SET_10} \
    ${HELM_SET_11:+--set $HELM_SET_11} \
    ${HELM_SET_12:+--set $HELM_SET_12} \
    ${HELM_SET_13:+--set $HELM_SET_13} \
    ${HELM_SET_14:+--set $HELM_SET_14} \
    ${HELM_SET_15:+--set $HELM_SET_15} \
    ${HELM_SET_16:+--set $HELM_SET_16} \
    ${HELM_SET_17:+--set $HELM_SET_17} \
    ${HELM_SET_18:+--set $HELM_SET_18} \
    ${HELM_SET_19:+--set $HELM_SET_19} \
    ${HELM_SET_20:+--set $HELM_SET_20} \
    ${HELM_SET_STRING_01:+--set-string $HELM_SET_STRING_01} \
    ${HELM_SET_STRING_02:+--set-string $HELM_SET_STRING_02} \
    ${HELM_SET_STRING_03:+--set-string $HELM_SET_STRING_03} \
    ${HELM_SET_STRING_04:+--set-string $HELM_SET_STRING_04} \
    ${HELM_SET_STRING_05:+--set-string $HELM_SET_STRING_05} \
    ${HELM_SET_STRING_06:+--set-string $HELM_SET_STRING_06} \
    ${HELM_SET_STRING_07:+--set-string $HELM_SET_STRING_07} \
    ${HELM_SET_STRING_08:+--set-string $HELM_SET_STRING_08} \
    ${HELM_SET_STRING_09:+--set-string $HELM_SET_STRING_09} \
    ${HELM_SET_STRING_10:+--set-string $HELM_SET_STRING_10} \
    ${HELM_SET_STRING_11:+--set-string $HELM_SET_STRING_11} \
    ${HELM_SET_STRING_12:+--set-string $HELM_SET_STRING_12} \
    ${HELM_SET_STRING_13:+--set-string $HELM_SET_STRING_13} \
    ${HELM_SET_STRING_14:+--set-string $HELM_SET_STRING_14} \
    ${HELM_SET_STRING_15:+--set-string $HELM_SET_STRING_15} \
    ${HELM_SET_STRING_16:+--set-string $HELM_SET_STRING_16} \
    ${HELM_SET_STRING_17:+--set-string $HELM_SET_STRING_17} \
    ${HELM_SET_STRING_18:+--set-string $HELM_SET_STRING_18} \
    ${HELM_SET_STRING_19:+--set-string $HELM_SET_STRING_19} \
    ${HELM_SET_STRING_20:+--set-string $HELM_SET_STRING_20} \
		${HELM_RELEASE} \
		${HELM_CHART}
EOF
)

  if [[ -n "$debug" ]]; then echo -e "\e[1;31m$(echo $command | sed ':a;N;$!ba;s#\\\n##g')\e[0m"; fi
  output=$(eval "$command")
  print_info --type=warning --text="##############################################################################################################"
  echo  "$output"
}

function helm_get_last_version () {
  set -e

  print_usage()
  {
    printf "usage: helm_get_last_version --env-file=my-env-file"
  }

  env_files=()
  while [ $# -gt 0 ]; do
    case "$1" in
      --env-file*)
        env_files+=("${1#*=}")
        ;;
      --pretty-print)
        pretty_print=1
        ;;
      --debug)
        debug=1
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  # if [ -z "$env_files" ]; then
  #   print_usage
  #   exit 1
  # fi

  for i in "${env_files[@]}"
  do
    eval $(cat $i)
  done

  if [ -z "$HELM_CHART" ]; then
    echo "environment var named HELM_CHART is required" && exit 1
  fi

  command="helm search repo ${HELM_CHART} --output yaml| yq e '.[0].version' -"
  if [[ -n "$debug" ]]; then print_info --type=command --text="$command"; fi
  output=$(eval "$command")
  repo_name=$(echo $HELM_CHART| cut -d"/" -f1)
  repo_chart=$(echo $HELM_CHART| cut -d"/" -f2)
  repo_url=$(helm repo list --output json|jq -r --arg name $repo_name '.[]|select( .name == $name)|.url')
  jo \
    REPO=$repo_name \
    URL=$repo_url \
    CHART=$repo_chart \
    LAST_VERSION=$output|yq e -P
}

function eval_env_files ()
{
  set -e
  for file in "$@"
  do
    eval $(cat $file)
    if [[ -n "$(sed -rn '/^KIND_CLUSTER_NAME=/p' $file)" ]]; then
      print_info --type=warning --text="eval_env_files - wait kind cluster ${KIND_CLUSTER_NAME} start ..."
      # print_info --type=warning --text="$(cat $file)"
      wait_cluster
    fi
  done
}

function deploy_helm_chart () {
  set -e

  print_usage()
  {
    printf "usage: deploy --env-file=my-env-file --debug"
  }

  env_files=()
  while [ $# -gt 0 ]; do
    case "$1" in
      --env-file*)
        env_files+=("${1#*=}")
        ;;
      --help)
        print_usage
        exit 0
        ;;
      --pretty-print)
        pretty_print=1
        ;;
      --debug)
        debug=1
        ;;
      --add-repo)
        add_repo=1
        ;;
      --get-last-version)
        get_last_version=1
        ;;
      --template)
        template=1
        ;;
      --pull-push-images)
        pull_push_images=1
        ;;
      --push-images)
        push_images=1
        ;;
      --debug)
        debug=1
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done

  # if [ -z "$env_files" ]; then
  #   print_usage
  #   exit 1
  # fi

  for i in "${env_files[@]}"
  do
    eval $(cat $i)
    if [[ -n "$(sed -rn '/^KIND_CLUSTER_NAME=/p' $i)" ]]; then
      print_info --type=warning --text="deploy_helm_chart - wait kind cluster ${KIND_CLUSTER_NAME} start ..."
      wait_cluster
    fi
  done

  if [ -n "$add_repo" ]; then
    helm_repo_add
  fi

  if [ -n "$get_last_version" ]; then
    helm_get_last_version
  fi

  if [ -n "$pull_push_images" ]; then
	  pull_push_images
  fi

  if [ -n "$template" ]; then
	  helm_template					${pretty_print:+--pretty-print} ${debug:+--debug}
  fi

	helm_upgrade					${debug:+--debug}
}

function import_certificates () {
  set -e

  if [ -z "$KUBE_CONTEXT" ]; then
    echo "environment var named KUBE_CONTEXT is required" && exit 1
  fi

  namespaces=$(kubectl get ns --context $KUBE_CONTEXT -o jsonpath='{.items[*].metadata.name}')
  # echo "namespaces: $namespaces"
  for n in $namespaces; do
    # echo "namespace: $n"
    secrets=$(kubectl get certificates.cert-manager.io --context $KUBE_CONTEXT -o jsonpath='{.items[*].spec.secretName}' --namespace=$n)
    # echo "secrets: $secrets"
    for s in $secrets; do
      echo "secret: $s"
      tempfile=$(mktemp /tmp/crt.XXXXXXXXXX)
      trap "rm -Rf $tempfile" 0 2 3 15
      file=$s.crt
      key=ca.crt
      kubectl get secrets/$s --context $KUBE_CONTEXT -o jsonpath="{.data.${key//./\\.}}" -n $n | base64 -d >> $tempfile
      nb=$(certutil -d sql:$HOME/.pki/nssdb -L | sed -rn "/^${file}\s+/p" | wc -l); until [[ $nb -eq 0 ]]; do sleep 1; certutil -d sql:$HOME/.pki/nssdb -D -n "${file}" && nb=$(certutil -d sql:$HOME/.pki/nssdb -L | sed -rn "/^${file}\s+/p" | wc -l); done
      certutil -d sql:$HOME/.pki/nssdb -A -t "CT,c,c" -n "${file}" -i $tempfile
      certutil -d sql:$HOME/.pki/nssdb -L
      # sudo cp $tempfile /usr/local/share/ca-certificates/${file}
    done
  done
  # sudo update-ca-certificates
  certutil -d sql:$HOME/.pki/nssdb -L
}

function prune_certificates () {
  set -e

  for c in $(certutil -d sql:$HOME/.pki/nssdb -L | cut -d' ' -f1 | sed -rn '/^.*\.crt/p'); do
    certutil -d sql:$HOME/.pki/nssdb -D -n $c
  done

  # certutil -d sql:$HOME/.pki/nssdb -L
  # sudo rm -Rf /usr/local/share/ca-certificates/*
  # sudo update-ca-certificates --fresh
  # sudo bash -c "find /etc/ssl/certs -type l ! -exec test -e {} \; -print0 | xargs -r0 rm"
}

function dl_dashboard () {
  set -e
  print_usage()
  {
    printf "usage: dl_dashboard --id=13639 --revision=1 --uid=am2PnSxES --tags=loki1 --tags=loki2 --argocd-notifications"
  }
  while [ $# -gt 0 ]; do
    case "$1" in
      --id=*)
        local id="${1#*=}"
        ;;
      --revision=*)
        local revision="${1#*=}"
        ;;
      --uid=*)
        local uid="${1#*=}"
        ;;
      --tags*)
        local tags+=("${1#*=}")
        ;;
      --argocd-notifications*)
        local argocd_notifications=1
        ;;
      --help)
        print_usage
        exit 0
        ;;
      *)
        print_usage
        exit 1
    esac
    shift
  done
  # echo "id: $id"
  if [ -z "$id" ]; then
    print_usage
    exit 1
  fi
  # echo "revision: $revision"
  if [ -z "$revision" ]; then
    print_usage
    exit 1
  fi
  if [ -z "$tags" ]; then
    print_usage
    exit 1
  fi


  args=
  for i in "${tags[@]}"
  do 
    args="$args $(echo -n 'array[]='$i)"
  done

  tags=$(jo $args|jq -c '.array')

  curl -skf \
  --connect-timeout 60 \
  --max-time 60 \
  -H "Accept: application/json" \
  -H "Content-Type: application/json;charset=UTF-8" \
    "https://grafana.com/api/dashboards/$id/revisions/$revision/download" | \
    sed '/-- .* --/! s/"datasource": "${DS_PROMETHEUS}",/"datasource": "Prometheus",/g' | \
    sed '/-- .* --/! s/"datasource": "$Datasource",/"datasource": "Prometheus",/g' | \
    sed '/-- .* --/! s/"datasource": "$datasource",/"datasource": "Prometheus",/g' | \
    sed '/-- .* --/! s/"datasource": "${DS_SYSTEM-PROMETHEUS}",/"datasource": "Prometheus",/g' | \
    sed '/-- .* --/! s/"datasource": "${DS_LOKI}",/"datasource": "Loki",/g' | \
    sed '/-- .* --/! s/"datasource": "${DS_LOKI-FGC-NGINX01}",/"datasource": "Loki",/g' > "dashboards/$id-$revision.json"

  if [ -n "$argocd_notifications" ]; then
    tempfile=$(mktemp /tmp/dashboard.XXXXXXXXXX)
    trap "rm -Rf $tempfile" 0 2 3 15
    cat "dashboards/$id-$revision.json" | jq '.annotations.list = [{"datasource": "-- Grafana --","enable": true,"hide": true,"iconColor": "rgb(255, 255, 255)","limit": 100,"name": "ArgoCD Notifications","showIn": 0,"tags": ["argocd"],"type": "tags"}]' > $tempfile
    mv $tempfile "dashboards/$id-$revision.json"
  fi

  tempfile=$(mktemp /tmp/dashboard.XXXXXXXXXX)
  trap "rm -Rf $tempfile" 0 2 3 15
  if [ -n "$uid" ]; then
    cat "dashboards/$id-$revision.json" | jq --arg uid $uid '.uid = $uid' > $tempfile
  else
    title=$(cat "dashboards/$id-$revision.json" | jq -r '.title')
    # echo $title
    title=$(sed -E 's/[^[:alnum:][:space:]]+/-/g' <<<"$title")
    # echo $title
    # title=$(sed -E 's/[([:alnum:])[:space:]([:alnum:])]/\1-\2/g' <<<"$title")
    title=$(sed -E 's/([[:alnum:]])[[:space:]]([[:alnum:]])/\1-\2/g' <<<"$title")
    # echo $title
    title=$(echo "${title,,}" | sed -r 's/\s+//g')
    # echo $title
    # title=$(echo "${title,,}" | sed -r 's/\s+//g')
    title=$(echo "${title,,}" | sed -r 's/\s+//g')
    # echo $title
    title=$(echo "${title,,}" | sed -r 's/^-//g' | sed -r 's/-$//g')
    # echo $title
    title=${title:0:40}
    echo $title
    # exit 1
    cat "dashboards/$id-$revision.json" | jq --arg uid $title '.uid = $uid' > $tempfile
  fi
  mv $tempfile "dashboards/$id-$revision.json"

  tempfile=$(mktemp /tmp/dashboard.XXXXXXXXXX)
  trap "rm -Rf $tempfile" 0 2 3 15
  # tags=$(jo array[]=loki array[]=tools|jq '.array')
  # tags=$(jo array[]="loki"|jq -c '.array')

  cat "dashboards/$id-$revision.json" | jq --argjson tags "${tags}" '.tags = $tags' > $tempfile
  mv $tempfile "dashboards/$id-$revision.json"

}

# Allows to call a function based on arguments passed to the script
$*