oc

#!/bin/bash

#set -o errexit
set -o errtrace
set -o nounset
set -o pipefail

# Handle source locations that might be a symlink (ref: http://bit.ly/2kcvSCS)
SOURCE="${BASH_SOURCE[0]}"
while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
  DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
  SOURCE="$(readlink "$SOURCE")"
  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
done
DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"

DOC="https://github.com/openshift-evangelists/oc-wrapper/blob/master/README.md"
SCRIPT_NAME=$(basename "$0")
OC_BINARY=${OC_BINARY:-"$DIR/oc-origin"}
OC_CONTEXT=${OC_CONTEXT:-""}
TIMEOUT=${OC_LOGIN_TIMEOUT:-"1s"}
OC_DEBUG_ENABLED=${OC_DEBUG_ENABLED:-"0"}  # Use log levels: 0 NONE, 1 ERROR, 2 WARN, 3 INFO, 4 DEBUG, 5 TRACE

[ ! -x ${OC_BINARY} ] && echo "The real oc binary \"${OC_BINARY}\" does not exist. Make sure it's renamed to something different than oc" && exit 1
[[ "" != "${OC_CONTEXT}" ]] && OC_BINARY="${OC_BINARY} --config=${OC_CONTEXT}"

################## AUXILIARY FUNCTIONS
#
#

function currentContext {
  local _ctx=$(${OC_BINARY} config current-context 2> /dev/null)
  # TODO: See if oc whoami -c is better
  echo "$_ctx"
}

function currentUser {
  local _ctx=${1:-}
  [ "${_ctx}" == "" ] && _ctx=$(currentContext)
  if [ "${_ctx}" == "" ]
  then
    echo ""
  else
    local _path="{.contexts[?(@.name == \"$_ctx\")].context.user}"
    local _user="$(${OC_BINARY} config view -o jsonpath="$_path" 2> /dev/null)"
    echo "$_user"
  fi
}

function currentCluster {
  local _ctx=${1:-}
  [ "${_ctx}" == "" ] && _ctx=$(currentContext)
  if [ "${_ctx}" == "" ]
  then
    echo ""
  else
    local _path="{.contexts[?(@.name == \"$_ctx\")].context.cluster}"
    local _cluster="$(${OC_BINARY} config view -o jsonpath="$_path" 2> /dev/null)"
    echo "$_cluster"
  fi
}

function _exec_oc {
  logInfo "Sending command to real oc"
  logDebug "Before"
  logDebug "exec ${OC_BINARY} $@"
  exec ${OC_BINARY} "$@"
  logDebug "After"
}

function _oc_newKubecfg {
  logInfo "Sending command to real oc"
  logDebug "Before"
  logDebug "KUBECONFIG=~/.kube/config.trash ${OC_BINARY} $@"
  cp -f ~/.kube/config ~/.kube/config.trash
  KUBECONFIG=~/.kube/config.trash ${OC_BINARY} "$@"
  local retCode=$?
  [ debugEnabled ] && rm -f ~/.kube/config.trash
  logDebug "After"
  return $retCode
}

function debugEnabled() {
  [ "$OC_DEBUG_ENABLED" == "" ] && return 0
}

function logDebug(){
  [ "$OC_DEBUG_ENABLED" -ge 4 ] && echo "[DEBUG] $@"
}

function logInfo(){
  [ "$OC_DEBUG_ENABLED" -ge 3 ] && echo "[INFO] $@"
}

################## MAIN SCRIPT
#
#

function help {
  echo "OpenShift Wrapper"
  echo ""
  echo "This wrapper helps work with contexts in a meaningful way"
  echo ""
  echo "Basic Commands:"
  echo ""
  echo "  login"
  echo "  logout"
  echo "  context-status"
  echo "  list"
  echo "  use <CONTEXT>"
  echo "  rename-context <NEW-CONTEXT-NAME>"
  echo "  delete-context <CONTEXT>"
  echo
  ${OC_BINARY} -h
  echo ""
  echo ""
  echo "See the documentation at $DOC"
}

function list {
  local _arg1=${1:-}

  [ "$_arg1" == "-h" ] || [ "$_arg1" == "--help" ] && ${FUNCNAME[0]}.help && return 0

  local _ctx=$(currentContext)
  for context in `${OC_BINARY} config view -o jsonpath='{range .contexts[*]}{.name}{" "}{end}'`
  do
    if [ "${context}" == "${_ctx}" ]
    then
      echo " - ${context}  ***********************"
    else
      echo " - ${context}"
    fi
  done
}

function list.help {
  echo "Lists existing contexts. It shows current context with a line of *"
  echo ""
  echo "See the documentation at $DOC"
}

function login {
  local _arg1=${1:-}
  local _retCode

  [ "$_arg1" == "-h" ] || [ "$_arg1" == "--help" ] && ${FUNCNAME[0]}.help && return 0

  # If there's no current context, delegate to real login
  local _ctx=$(currentContext)
  if [ "" == "${_ctx}" ]
  then
    ${OC_BINARY} login "$@"
  else
    # TODO: If we're connecting to a net new cluster there will be parameters
    if [ "${_arg1}" != "" ]
    then
      ${OC_BINARY} login "$@"
    else
      ${OC_BINARY} whoami --request-timeout=$TIMEOUT > /dev/null 2>&1
      _retCode=$?
      if [ $_retCode -ne 0 ]; then
        # Check to see if the server is up
        ${OC_BINARY} whoami --request-timeout=$TIMEOUT /dev/null 2> /tmp/oc-whoami-err.temp
        grep "Client.Timeout" /tmp/oc-whoami-err.temp > /dev/null 2>&1
        _retCode=$?
        rm -f /tmp/oc-whoami-err.temp
        if [ $_retCode -ne 0 ]; then
          local _ctx=$(${OC_BINARY} whoami -c)
          local _cluster=$(${OC_BINARY} whoami --show-server)
          local _user=$(${OC_BINARY} config view -o jsonpath='{.contexts[?(@.name == "'${_ctx}'")].context.user}' | cut -f 1 -d '/')
          echo "oc login ${_cluster} -u ${_user} --request-timeout=2s"
          ${OC_BINARY} login ${_cluster} -u ${_user} --request-timeout=$TIMEOUT
          _retCode=$?
          if [ $_retCode -eq 0 ]; then
            # TODO: Login might change the username/cluster if it has been customized.
            ${OC_BINARY} config delete-context ${_ctx} > /dev/null 2>&1
            ${OC_BINARY} config rename-context $(${OC_BINARY} whoami -c) ${_ctx} > /dev/null 2>&1
            echo "User has succesfully logged back to ${_ctx}"
          else
            echo "There's been an error trying to log the user back in"
          fi
        else
          echo "There's been a Timeout error trying to log the user back in. Is the server up and reachable?"
        fi
      else
        echo "User is already logged in and valid. Context is $(${OC_BINARY} whoami -c)"
      fi
    fi
  fi
}

function login.help {
  echo "Validates that the user is logged in with the current context, and if not, it logs it in"
  echo ""
  echo "See the documentation at $DOC"
}

function use {
  local _arg1=${1:-}

  [ "$_arg1" == "-h" ] || [ "$_arg1" == "--help" ] && ${FUNCNAME[0]}.help && return 0

  local _ctx=$(currentContext)
  [ "${_ctx}" == "${_arg1}" ] && return

  ${OC_BINARY} config use-context ${_arg1}
}

function use.help {
  echo "Changes to the specified context"
  echo ""
  echo "Usage:"
  echo " $SCRIPT_NAME use <CONTEXT>"
  echo ""
  echo "See the documentation at $DOC"
}

function project {
  local _arg1=${1:-}

  [ "$_arg1" == "-h" ] || [ "$_arg1" == "--help" ] && ${FUNCNAME[0]}.help && return 0

  local _ctx=$(currentContext)
  [ "" == "${_arg1}" ] && _exec_oc project -h && return
  [ "-q" == "${_arg1}" ] && _exec_oc project -q && return
  [[ ${_arg1} == --short* ]] && _exec_oc project $_arg1 && return

  ${OC_BINARY} config set-context ${_ctx} --namespace=${_arg1} > /dev/null 2>&1
  _cluster_name=$(${OC_BINARY} config view -o jsonpath='{.contexts[?(@.name == "'${_ctx}'")].context.cluster}')
  _cluster=$(${OC_BINARY} config view -o jsonpath='{.clusters[?(@.name == "'${_cluster_name}'")].cluster.server}')
  echo "Now using project \"${_arg1}\" on server \"$_cluster\"."
}

function project.help {
  ${OC_BINARY} project -h
}

function new-project {
  local _arg1=${1:-}

  [ "$_arg1" == "-h" ] || [ "$_arg1" == "--help" ] && ${FUNCNAME[0]}.help && return 0

  local _ctx=$(currentContext)
  [ "" == "${_arg1}" ] && _exec_oc new-project -h && return
  _oc_newKubecfg new-project "$@"
  # Only change current context if previous action succeeds.
  if [ "$?" -eq "0" ]
  then
    ${OC_BINARY} config set-context ${_ctx} --namespace=${_arg1} > /dev/null 2>&1
  fi
}

function new-project.help {
  ${OC_BINARY} new-project -h
}
function delete-project {
  local _arg1=${1:-}

  [ "$_arg1" == "-h" ] || [ "$_arg1" == "--help" ] && ${FUNCNAME[0]}.help && return 0

  local _ctx=$(currentContext)
  [ "" == "${_arg1}" ] && _exec_oc delete project -h && return 
  ${OC_BINARY} delete project "$@"
  # Only change current context if previous action succeeds.
  if [ "$?" -eq "0" ]
  then
    ${OC_BINARY} config set-context ${_ctx} --namespace= > /dev/null 2>&1
  fi
}

function delete-project.help {
  ${OC_BINARY} delete project -h
}

function rename-context {
  local _arg1=${1:-}

  [ "$_arg1" == "-h" ] || [ "$_arg1" == "--help" ] && ${FUNCNAME[0]}.help && return 0

  local _ctx=$(currentContext)
  [ "" == "${_arg1}" ] && echo "You need to specify a new context name" && return
  [ "${_ctx}" == "${_arg1}" ] && return

  ${OC_BINARY} config rename-context ${_ctx} ${_arg1}
}

function rename-context.help {
  echo "Renames the current context"
  echo ""
  echo "Usage:"
  echo " $SCRIPT_NAME rename-context <NEW-CONTEXT-NAME>"
  echo ""
  echo "See the documentation at $DOC"
}

function delete-context {
  local _arg1=${1:-}

  [ "$_arg1" == "-h" ] || [ "$_arg1" == "--help" ] && ${FUNCNAME[0]}.help && return 0

  [ "" == "${_arg1}" ] && echo "You need to specify a context name" && return

  # echo "${OC_BINARY} config view -o jsonpath='{.contexts[?(@.name == \"$_arg1\")].context.user}'"
  local __user=$(currentUser $_arg1)
  local __cluster=$(currentCluster $_arg1)

  ${OC_BINARY} config unset users.${__user} &> /dev/null
  ${OC_BINARY} config unset clusters.${__cluster} &> /dev/null
  ${OC_BINARY} config delete-context ${_arg1} &> /dev/null
  if [ "$(currentContext)" == "${_arg1}" ]
  then
    ${OC_BINARY} config unset current-context &> /dev/null
    echo "Current OC context has been unset. Please use \"oc list\" to list available context, and \"oc use <context-name>\" to set one"
  fi
}

function delete-context.help {
  echo "Deletes the specified context"
  echo ""
  echo "Usage:"
  echo " $SCRIPT_NAME delete-context <CONTEXT-NAME>"
  echo ""
  echo "See the documentation at $DOC"
}

function context-status {
  local _arg1=${1:-}

  [ "$_arg1" == "-h" ] || [ "$_arg1" == "--help" ] && ${FUNCNAME[0]}.help && return 0

  local _ctx=$(currentContext)

  [ "$_ctx" == "" ] && echo "There's no context selected. Use 'oc use <context-name>' or 'oc list'" && return 0

  # Two cases, if named context
  local _project=""
  local _user=""
  local _cluster=""

  _project=$(${OC_BINARY} config view -o jsonpath='{.contexts[?(@.name == "'${_ctx}'")].context.namespace}' 2> /dev/null)
  _cluster_name=$(${OC_BINARY} config view -o jsonpath='{.contexts[?(@.name == "'${_ctx}'")].context.cluster}' 2> /dev/null)
  _cluster=$(${OC_BINARY} config view -o jsonpath='{.clusters[?(@.name == "'${_cluster_name}'")].cluster.server}' 2> /dev/null)
  _user=$(${OC_BINARY} config view -o jsonpath='{.contexts[?(@.name == "'${_ctx}'")].context.user}' | cut -f 1 -d '/' 2> /dev/null)
  ${OC_BINARY} get user/~ -o name --token "$(${OC_BINARY} whoami -t)" > /dev/null 2>&1
  _connected=$?

  echo "You're using profile: ${_ctx}"
  [ $_connected -eq 0 ] && echo "[INFO] You're currently connected. Token is still valid" || echo "[ERROR] You're currently disconnected. Token is no longer valid"
  echo " "
  echo "Cluster: ${_cluster}"
  echo "User: ${_user}"
  echo "Project: ${_project}"
}

function context-status.help {
  echo "Status "
  echo ""
  echo "Available Arguments:"
  echo ""
  echo ""
  echo "See the documentation at $DOC"
}

function logout {
  sed -i -e 's/current-context:.*/current-context:/g' ~/.kube/config
}

function logout.help {
  echo "Logs the user out"
  echo ""
  echo "See the documentation at $DOC"
}

if [[ $# -gt 0 ]]
then
   key="$1"
   case $key in
      login)
        shift # past argument
        login "$@"
        ;;
      logout)
        logout
        ;;
      list)
        shift # past argument
        list "$@"
        ;;
      use)
        shift # past argument
        use "$@"
        ;;
      project)
        shift # past argument
        project "$@"
        ;;
      new-project)
        shift # past argument
        new-project "$@"
        ;;
      rename-context)
        shift # past argument
        rename-context "$@"
        ;;
      delete-context)
        shift # past argument
        delete-context "$@"
        ;;
      delete)
        if [ "$2" == "project" ]
        then
          shift 2
          delete-project "$@"
        else
          _exec_oc "$@"
        fi
        ;;
      context-status)
        context-status
        ;;
      -h|--help)
        help
        ;;
      *)
        _exec_oc "$@"
        ;;
   esac
else
   help
fi