maps-tools

#!/usr/bin/env bash

#needs to increment on every change!!!
#version: 36

#initialize variables
readonly DEFAULT_DOCKER_IMAGE_REGISTRY="ghcr.io/spring-media"
readonly DEFAULT_DOCKER_IMAGE_NAME=maps-tools
readonly DEFAULT_DOCKER_IMAGE_TAG=latest
readonly DEFAULT_DOCKER_IMAGE_TAG_TESTING=testing
readonly DEFAULT_DOCKER_IMAGE="${DEFAULT_DOCKER_IMAGE_REGISTRY}/${DEFAULT_DOCKER_IMAGE_NAME}:${DEFAULT_DOCKER_IMAGE_TAG}"
readonly DEFAULT_DOCKER_IMAGE_TESTING="${DEFAULT_DOCKER_IMAGE_REGISTRY}/${DEFAULT_DOCKER_IMAGE_NAME}:${DEFAULT_DOCKER_IMAGE_TAG_TESTING}"
readonly DEFAULT_DOCKER_USERNAME=k8s
USE_DOCKER_IMAGE=false
DEFAULT_STAGE=$AWS_PROFILE
USE_AWS_VOLUME=true
CREATE_DAEMON_CONTAINER=false
CONTAINER_ATTACH=false
UPDATE=false
CLEANUP_CONFIGS=false
SESSION_KUBECONFIG=false
K8S_DASHBOARD=false
RELEASE=
USER_NAME=${HOME##*/}
DOCKER_STARTED=false

declare -a ADDITIONAL_CONTAINER_ARGS
volumes[0]="-v $HOME/.aws:/home/$DEFAULT_DOCKER_USERNAME/.aws"
volumes[1]="-v $HOME:/home/$USER_NAME"
volumes[2]="-v $HOME/.ssh:/home/$DEFAULT_DOCKER_USERNAME/.ssh"
volumes[3]="-v $HOME/.helm:/home/$DEFAULT_DOCKER_USERNAME/.helm"
volumes[4]="-v $HOME/.kube:/home/$DEFAULT_DOCKER_USERNAME/.kube"
volumes[5]="-v $HOME/.spacelift:/home/$DEFAULT_DOCKER_USERNAME/.spacelift"
volumes[6]="-v $HOME/.terraformrc:/home/$DEFAULT_DOCKER_USERNAME/.terraformrc"

declare -a ports

# select 5 random ports that are not in use from range 8000-8999
for i in {8000..8999}
do
  if nc -z 127.0.0.1 ${i} -w2 2>/dev/null ; then
    if [ "${i}" == "8999" ] ; then
      echo "all local ports 8000-8999 are in use"
      exit
    else
      continue
    fi
  else
    ports+=("${i}")
  fi

  if [ "${#ports[@]}" == "5" ]; then
    break
  fi
done

[ ! -f ~/.terraformrc ] && touch ~/.terraformrc
[ ! -d ~/.spacelift ] && mkdir ~/.spacelift

function print_usage() {
  echo
  echo "Usage: $0 [-e] [-v] [-h] [-i] [-d] [-a] [-c] [-o] [-u] [-x] [-s] [-r]"
  echo '-e: Environment example (AWS_PROFILE NAME: mediasites-stage.dev|mediasites-prod.admin)'
  echo '-v: DO NOT USE a Docker volume mount for local .aws, .ssh, .helm and .kube configs inside the container.'
  echo '-h: Print this help text'
  echo '-i: Ask for a local Docker image to use'
  echo '-d: create daemon container that runs in the background, so you can use docker exec to connect to'
  echo '-a: attach to daemon container that previously created with -d option'
  echo '-c: cleanup/delete your actual .aws/config, .aws/credentials and .kube/config-* files, backup of old files will be created .aws/config-$DATE, e.g. .aws/config-20220504123050'
  echo '-o: add aditional cmd parameter to docker run/create command, IMPORTANT: use double quotes! you can use this option more than one time, e.g. -o "-p 2222:22" -o "-e DISPLAY=host.docker.internal:0"'
  echo '-u: update maps-tools and docker image (force pull), to get testing versions use "-u testing"'
  echo '-x: start with kubernetes dashboard http://0.0.0.0:7777/'
  echo '-s: start a container with individual kube context'

  echo

  exit 0
}

function create_docker_run_command() {
  [ $# -ne 1 ] && echo ❌ No image name given to function \"create_docker_run_command\" && return
  local docker_string=""
  local image_name="$1"
  local start_path=""

  if [ "${#ports[@]}" == "0" ]; then
    ports_string=""
  else
    for value in "${ports[@]}"; do
      ports_string+="-p ${value}:${value} "
      port_variable+="${value} "
    done
  fi

  if [[ "${K8S_DASHBOARD}" == true ]]; then
    dashboard_string=" -p 7777:7777 -e OCTANT_LISTENER_ADDR=0.0.0.0:7777 -e K8S_DASHBOARD=true "
  else 
    dashboard_string=" -e K8S_DASHBOARD=false "
  fi

  start_path=$PWD
  if [[ $start_path =~ "$HOME" ]]; then
    start_path="${start_path//Users/home}"
  else
    start_path="/home/$USER"
  fi

  case true in
    "$CREATE_DAEMON_CONTAINER")
      if [[ $(docker ps -a --format "{{.Names}}" --filter "name=maps-tools") == "maps-tools" ]]
      then
        docker rm -f maps-tools 2>&1 >/dev/null
      fi
      if [[ "${USE_AWS_VOLUME}" == true ]]
      then
        docker_string="docker create --name maps-tools ${volumes[*]} ${ports_string} ${dashboard_string} -e \"PORT_VARIABLE=$port_variable\" -e \"AWS_PROFILE=$DEFAULT_STAGE\" -e \"DEFAULT_SESSION_KUBECONFIG=$SESSION_KUBECONFIG\" -e \"START_PATH=$start_path\" ${ADDITIONAL_CONTAINER_ARGS[@]} --entrypoint \"/init/init_daemon.sh\" $image_name"
      else
        docker_string="docker create --name maps-tools ${volumes[1]} ${ports_string} ${dashboard_string} -e \"PORT_VARIABLE=$port_variable\" -e \"AWS_PROFILE=$DEFAULT_STAGE\" -e \"DEFAULT_SESSION_KUBECONFIG=$SESSION_KUBECONFIG\" -e \"START_PATH=$start_path\" ${ADDITIONAL_CONTAINER_ARGS[@]} --entrypoint \"/init/init_daemon.sh\" $image_name"
      fi
      ;;
    "$CONTAINER_ATTACH")
      if [[ $(docker ps --format "{{.Names}}" --filter "name=maps-tools") == "maps-tools" ]]
      then
        docker_string="docker exec -ti -e \"START_PATH=$start_path\" -e \"AWS_PROFILE=$DEFAULT_STAGE\" -e \"DEFAULT_SESSION_KUBECONFIG=$SESSION_KUBECONFIG\" ${ADDITIONAL_CONTAINER_ARGS[@]} maps-tools /usr/bin/bash --login"
      elif [[ $(docker ps -a --format "{{.Names}}" --filter "name=maps-tools") == "maps-tools" ]]
      then
        docker_string="docker start maps-tools; docker exec -ti -e \"START_PATH=$start_path\" -e \"AWS_PROFILE=$DEFAULT_STAGE\" -e \"DEFAULT_SESSION_KUBECONFIG=$SESSION_KUBECONFIG\" ${ADDITIONAL_CONTAINER_ARGS[@]} maps-tools /init/init.sh"
      fi
      ;;
    *)

      if [[ "${USE_AWS_VOLUME}" == true ]]
      then
        docker_string="docker run -it --rm ${volumes[*]} ${ports_string} ${dashboard_string} -e \"PORT_VARIABLE=$port_variable\" -e \"START_PATH=$start_path\" -e \"AWS_PROFILE=$DEFAULT_STAGE\" -e \"DEFAULT_SESSION_KUBECONFIG=$SESSION_KUBECONFIG\" ${ADDITIONAL_CONTAINER_ARGS[@]} $image_name"
      else
        docker_string="docker run -it --rm ${volumes[1]} ${ports_string}  ${dashboard_string} -e \"PORT_VARIABLE=$port_variable\" -e \"START_PATH=$start_path\" -e \"AWS_PROFILE=$DEFAULT_STAGE\" -e \"DEFAULT_SESSION_KUBECONFIG=$SESSION_KUBECONFIG\" ${ADDITIONAL_CONTAINER_ARGS[@]} $image_name"
      fi
      ;;
  esac
  echo "$docker_string"
}

function run_docker_image() {
  local image=${DEFAULT_DOCKER_IMAGE}

  if [[ "${CREATE_DAEMON_CONTAINER}" == true && "${CONTAINER_ATTACH}" == true ]]
  then
    echo "you cannot use -d and -a Option simultaneously"
    exit 1
  fi
  case true in
    "$USE_DOCKER_IMAGE")
      declare -a docker_images=( $(docker images |grep ${DEFAULT_DOCKER_IMAGE_NAME} |awk '{ print $1 ":" $2 }') )
      if [ ${#docker_images[@]} -eq 0 ]; then echo ❌ Image not found. Run \"make build\" or download image from \"GitHub Package Repository\" !; exit 1; fi
      PS3="Choose the image to run: "
      select docker_image_name in "${docker_images[@]}"; do
        if (( $REPLY >= 1 && $REPLY < (( "${#docker_images[@]}" + 1)) )); then
          local image="${docker_images[(($REPLY - 1))]}"
          local docker_run_command="$(create_docker_run_command "$image")"
          eval $docker_run_command
        else
          echo ❌ Invalid choice && exit 1
        fi
        break
      done
      ;;
    *)
      local docker_run_command="$(create_docker_run_command "$image")"
      eval $docker_run_command
    ;;
  esac
}

function get_script() {
  if [ -f ./maps-tools ]; then
    cp -f ./maps-tools /tmp/maps-tools
  else
    curl -s https://raw.githubusercontent.com/spring-media/maps-tools-install/main/maps-tools${RELEASE} >/tmp/maps-tools
  fi
  retVal=$?
  if [ $retVal -ne 0 ]; then
    echo "Error getting version of maps-tools"
    exit $retVal
  fi
}

function install_script() {
  if [ -f /tmp/maps-tools ]; then
    echo "If ask, enter your AD password to install maps-tools into /usr/local/bin/maps-tools"
    cp -f /tmp/maps-tools /usr/local/bin/maps-tools 1>&- 2>&- || sudo cp -f /tmp/maps-tools /usr/local/bin/maps-tools
    chmod 755 /usr/local/bin/maps-tools 1>&- 2>&- || sudo chmod 755 /usr/local/bin/maps-tools
  else
    echo "no version of maps-tools found for installation"
    exit 1
  fi
}

function check_for_updates() {
  if [ -f /tmp/maps-tools ]; then
    local version=$(grep -m 1 "#version:" /usr/local/bin/maps-tools | awk '{print $2}')
    local new_version=$(grep -m 1 "#version:" /tmp/maps-tools | awk '{print $2}')
    if [ ${version} -lt ${new_version} ]; then
      echo "upgrading maps-tools to version ${new_version}"
      install_script
    else
      echo "no upgrade available for maps-tools"
    fi
  else
    echo "no version of maps-tools found for installation"
    exit 1
  fi
}

function cleanup_tmp() {
  if [ -f /tmp/maps-tools ]; then
    rm -f /tmp/maps-tools
  fi
}

function docker_pull() {
  if [[ -z $RELEASE ]]; then
    docker pull ${DEFAULT_DOCKER_IMAGE}
  elif [[ -n $RELEASE ]]; then
    docker pull ${DEFAULT_DOCKER_IMAGE_TESTING}
  fi
}

function getopts_get_optional_argument() {
  eval next_token=\${$OPTIND}
  if [[ -n $next_token && $next_token != -* ]]; then
    OPTIND=$((OPTIND + 1))
    OPTARG=$next_token
  else
    OPTARG=""
  fi
}

function cleanup_configs() {
  [[ -s "${HOME}/.aws/config" ]] && \
  { echo "safe old ${HOME}/.aws/config to ${HOME}/.aws/config-$(date +%Y%m%d%H%M%S)"; mv -f ${HOME}/.aws/config ${HOME}/.aws/config-$(date +%Y%m%d%H%M%S); }
  [[ -s "${HOME}/.aws/credentials" ]] && \
  { echo "safe old ${HOME}/.aws/credentials to ${HOME}/.aws/credentials-$(date +%Y%m%d%H%M%S)"; mv -f ${HOME}/.aws/credentials ${HOME}/.aws/credentials-$(date +%Y%m%d%H%M%S); }
  [[ -s "${HOME}/.aws/awsctx" ]] && \
  { echo "safe old ${HOME}/.aws/awsctx to ${HOME}/.aws/awsctx-$(date +%Y%m%d%H%M%S)"; mv -f ${HOME}/.aws/awsctx ${HOME}/.aws/awsctx-$(date +%Y%m%d%H%M%S); }
  [[ -s "${HOME}/.kube/config" ]] && \
  { echo "safe old ${HOME}/.kube/config to ${HOME}/.kube/config-$(date +%Y%m%d%H%M%S)"; mv -f ${HOME}/.kube/config ${HOME}/.kube/config-$(date +%Y%m%d%H%M%S); }
  for i in ${HOME}/.kube/*config-*; do
    [[ -s "${i}" ]] && \
    { echo "safe old ${i} to ${i%/*}/backup-${i#*/*config-}-$(date +%Y%m%d%H%M%S)"; mv -f ${i} ${i%/*}/backup-${i#*/*config-}-$(date +%Y%m%d%H%M%S); }
  done
}

# Parse flags
while getopts "b:o:he:ivdaucsx" argument; do
  case "${argument}" in
    b)
      # Will be eventually used for additional BUILD ARGs later. Currently, the only BUILD ARG is directly
      # handled in "create_docker_run_command"
      echo 🛠️ TODO !
      ;;
    e)
      DEFAULT_STAGE="${OPTARG}"
      ;;
    v)
      USE_AWS_VOLUME=false
      ;;
    i)
      USE_DOCKER_IMAGE=true
      ;;
    d)
      CREATE_DAEMON_CONTAINER=true
      ;;
    a)
      CONTAINER_ATTACH=true
      ;;
    c)
      CLEANUP_CONFIGS=true;
      ;;
    s)
      SESSION_KUBECONFIG=true;
      ;;
    u)
      getopts_get_optional_argument $@
      if [[ "${OPTARG}" == "testing" ]]; then
        RELEASE="-testing"
      fi
      UPDATE=true
      ;;
    o)
      ADDITIONAL_CONTAINER_ARGS+=("$OPTARG")
      ;;
    x)
      K8S_DASHBOARD=true
      ;;
    
    h | ? | *)
      print_usage
      ;;
  esac
done
shift $((OPTIND - 1))

#self installation or upgrade
if [ ! -x /usr/local/bin/maps-tools ]; then
  echo "installing maps-tools to /usr/local/bin"
  echo ""

  get_script
  install_script
  cleanup_tmp

  echo 'add /usr/local/bin to your $PATH environment variable'
  echo 'for example:'
  echo ''
  echo 'bash:'
  echo 'echo export PATH="/usr/local/bin:\$PATH" >> ${HOME}/.bashrc && source ${HOME}/.bashrc'
  echo 'zsh:'
  echo 'echo export PATH="/usr/local/bin:\$PATH" >> ${HOME}/.zshrc && source ${HOME}/.zshrc'
  echo ''
  exit 0
elif [ -x /usr/local/bin/maps-tools ] && [ "$UPDATE" = true ]; then
  get_script
  check_for_updates
  cleanup_tmp
  docker_pull
  exit 0
elif [ -x /usr/local/bin/maps-tools ] && [ "${0##*/}" != "maps-tools" ]; then
  get_script
  check_for_updates
  cleanup_tmp
  docker_pull
  exit 0
fi

#cleanup aws and kube config
if [[ "$CLEANUP_CONFIGS" == "true" ]]; then
  while true; do
    read -p "Are you really sure to cleanup your .aws and .kube config files?" yn
    case $yn in
      [Yy]* ) cleanup_configs; break;;
      * ) echo "nothing clean up"; break;;
    esac
  done
  exit 0
fi

#check docker is installed
if [ ! -d "/Applications/Rancher Desktop.app" ] && [ ! -d "/Applications/Docker.app" ]; then
  echo "No Rancher Desktop or Docker Desktop found, only these are official supported"
fi

if [ `lsof -U | grep docker.sock | wc -l` -gt 0 ]; then
  echo "Docker is running"
  DOCKER_STARTED=true
else
  if [ -e "/Applications/Rancher Desktop.app" ]; then 
    echo "Starting Rancher Desktop"
    open /Applications/Rancher\ Desktop.app
    echo "please use the dockerd runtime with Rancher Desktop - containerd is not supported yet"
  elif [ -e "/Applications/Docker.app" ]; then 
    echo "Starting Docker Desktop"
    open /Applications/Docker.app
  fi

  START_CNT=0
  STEP_CNT=5
  MAX_CNT=$((240 / STEP_CNT))
  while [ $START_CNT -lt $MAX_CNT ]; do
    sleep $STEP_CNT
    START_CNT=$((START_CNT++))
    echo -n "."
    if [ `lsof -U | grep docker.sock | wc -l` -gt 0 ]; then
      echo
      echo "Docker was started"
      START_CNT=$((++MAX_CNT))
      DOCKER_STARTED=true
      sleep 5
    fi
  done

  echo
  if [ !$DOCKER_STARTED ]; then 
    echo "Docker couldn't be started"
  fi
fi

# Call function to obtain the proper call to docker run
if [ $DOCKER_STARTED ]; then
  run_docker_image
fi