awx-common

#!/bin/bash

# This script comes with ABSOLUTELY NO WARRANTY, use at own risk
# Copyright (C) 2020 Osiris Alejandro Gomez <osiris@gcoop.coop>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.

# shellcheck disable=SC2016
# shellcheck disable=SC2028
# shellcheck disable=SC2034
# shellcheck disable=SC2046
# shellcheck disable=SC2086
# shellcheck disable=SC2181

[[ -n "$TERM" ]] && export TERM='screen-256color'

RED="$(tput setaf 196)"
GREEN="$(tput setaf 46)"
NORMAL="$(tput sgr0)"
DIR_REAL="$(realpath "$DIR_BIN")"
DIR_BASE="$(dirname "$DIR_REAL")"
AWX_CONFIG="$HOME/.awx-config"
AWX_BACKUP="$HOME/.awx-config-$(date +%s).bak"
BIN=$(basename "$0")
AWX_CFG="$HOME/.tower_cli.cfg"

die ()
{
  stderror "${RED}[ERROR] $1 $NORMAL"
  [[ "$ERROR_SHOW_USAGE" -eq 1 ]] && usage
  exit 1
}

log ()
{
  local NOW
  NOW="$(date +'%F %T')"
  printf "%s\\n" "${NORMAL}${NOW} [INFO] $1 $NORMAL"
}

log_send_file()
{
  MAX_COLS="$(tput cols)"
  awx_cfg_read
  echo "SEND $1 to $AWX_CFG_HOST *****"
}

success ()
{
  printf "%s\\n" "${GREEN}[OK] $1 $NORMAL" && exit 0
}

stderror ()
{
  echo >&2 "$1"
}

markdown()
{
cat << EOF
---
fontsize: 8pt
code-block-font-size: 8pt
classoption: landscape
---
EOF
}

code()
{
  printf "\\n\\n%s\\n\\n" '```'
}

title1()
{
  printf "\\n# %s\\n\\n" "$1"
}

title2()
{
  printf "\\n## %s\\n\\n" "$1"
}

title3()
{
  printf "\\n### %s\\n\\n" "$1"
}

get_file_list()
{
  local DIR
  DIR='.'

  [[ -z "$1" ]] && exit 1
  [[ -z "$2" ]] || DIR="$2"

  find -L "$DIR" -type f -iname "$1" | while read -r FILE
  do
    echo "$FILE"
  done

}

filelist_projects()
{

  get_file_list "$PROJECT_PREFIX*.json" "$DIR_PROJECT"

}

filelist_inventory()
{
  [[ -d "$DIR_INVENTORY" ]] || die "NOT FOUND $PWD/$DIR_INVENTORY"

  get_file_list '*.json' "$DIR_INVENTORY"

}

filelist_job_templates()
{

  get_file_list "$JOB_TEMPLATE_PREFIX*.json" "$DIR_JOB_TEMPLATE"

}

filelist_workflows()
{

  get_file_list "$WORKFLOW_PREFIX*.json" "$DIR_WORKFLOW"

}

filelist_send_all()
{
  local FILE

  [[   -z "$1" ]] && die "EMPTY FILE"
  [[   -e "$1" ]] || die "NOT FOUND FILE"

  while read -r FILE
  do
    log_send_file "$FILE"
    echo awx-cli send $AWX_DEBUG "$FILE" | bash
  done < "$1"

}

grant_inventory_admin()
{
  awx-cli role grant \
    -v               \
    --type admin     \
    --team "$2"      \
    --inventory "$1"
}

grant_inventory_use()
{
  awx-cli role grant \
    -v               \
    --type use       \
    --team "$2"      \
    --inventory "$1"
}

grant_inventory()
{
  grant_inventory_use "$1" "$2"
}

grant_project()
{
  local TYPE

  TYPE='use'

  [[ -z "$3" ]] || TYPE="$3"

  echo awx-cli role grant \
    "$AWX_DEBUG"          \
    --type "$TYPE"        \
    --team "$2"           \
    --project "$1"        | bash
}

grant_project_use()
{
  grant_project "$1" "$2" 'use'
}

grant_project_admin()
{
  grant_project "$1" "$2" 'admin'
}

grant_job_template()
{
  local TYPE

  TYPE='execute'

  [[ -z "$3" ]] || TYPE="$3"

  echo awx-cli role grant \
    "$AWX_DEBUG"          \
    --type "$TYPE"        \
    --team "$2"           \
    --job-template "$1"   | bash
}

grant_job_template_admin()
{
  grant_job_template "$1" "$2" 'admin'
}

grant_job_template_execute()
{
  grant_job_template "$1" "$2" 'execute'
}

grant_workflow()
{
  local TYPE

  TYPE='execute'

  [[ -z "$3" ]] || TYPE="$3"

  echo awx-cli role grant \
    $AWX_DEBUG            \
    --type "$TYPE"        \
    --team "$2"           \
    --workflow "$1"       | bash
}

grant_workflow_execute()
{
  grant_workflow "$1" "$2" 'execute'
}

role_list_team_credential()
{
awx-cli role list $AWX_DEBUG          \
  --all-pages                         \
  --team "$1"                         \
  --credential "$2"                   \
  -f human                2>/dev/null \
  | grep -wE "$2.*credential"         \
  | awk '{print $2}'
}

role_list_team_project()
{
awx-cli role list $AWX_DEBUG          \
  --all-pages                         \
  --team "$1"                         \
  --project "$2"                      \
  -f human                2>/dev/null \
  | grep -wE "$2.*project"            \
  | awk '{print $2}'
}

role_list_team_inventory()
{
awx-cli role list $AWX_DEBUG          \
  --all-pages                         \
  --team "$1"                         \
  --inventory "$2"                    \
  -f human                2>/dev/null \
  | grep -wE "$2.*inventory"          \
  | awk '{print $2}'
}

role_list_team_job_template()
{
awx-cli role list $AWX_DEBUG          \
  --all-pages                         \
  --team "$1"                         \
  --job-template "$2"                 \
  -f json                 2>/dev/null \
  | jq -r .results[].name 2>/dev/null
}

role_list_team_workflow()
{
awx-cli role list $AWX_DEBUG          \
  --all-pages                         \
  --team "$1"                         \
  --workflow "$2"                     \
  -f json                 2>/dev/null \
  | jq -r .results[].name 2>/dev/null
}

role_list_team_csv()
{
  # $1 RESOURSE_TYPE
  # $2 RESOURSE_NAME
  # $3 TYPE
  # $4 TEAM
  printf "%s,%s,%s,%s\\n" "$1" "$2" "$3" "$4"
}

role_list_team_table()
{
  # $1 RESOURSE_TYPE
  # $2 RESOURSE_NAME
  # $3 TYPE
  # $4 TEAM
  printf "| %-20s | \`%-38s\` | %-10s | %-20s |\\n" \
         "_${1}_"                                   \
         "$2"                                       \
         "_${3}_"                                   \
         "_${4}_"
}

group_get_id()
{
  awx-cli group get  \
    --inventory "$1" \
    --name "$2"      \
    --format id
}

host_get_id()
{
  awx-cli host get   \
    --inventory "$1" \
    --name "$2"      \
    --format id
}

host_associate()
{
  awx-cli host associate \
    --host "$1"          \
    --group "$2"
}

host_list_enabled()
{

awx-cli host list  \
  --inventory "$1" \
  --enabled true   \
  --all-pages      \
  --format id      \
  | tr ' ' '\n'    \
  | grep -vE '^$'

}

inventory_get_id()
{
  awx-cli inventory get \
    --format id         \
    --name "$1"
}

host_disable()
{
  awx-cli host modify   \
    --enabled false     \
    --inventory "$1"    \
    --format human "$2"
}


log_ansible_proxmox_kvm()
{

  [[ -e "$1" ]] || die "NOT FOUND FILE $1"

  local DATE HOST VMID STATE

  grep 'ansible-proxmox_kvm:' "$1" | while read -r LINE
  do
    DATE="$(echo "$LINE" | cut -c -15)"
    HOST="$(echo "$LINE" | awk '{print $4}')"
    VMID="$(echo "$LINE" | grep -oE 'vmid=[0-9]+')"
    STATE="$(echo "$LINE" | grep -oE 'state=[a-z]+')"
    printf "%s %s ansible-proxmox_kvm: %s %s\\n" "$DATE" "$HOST" "$VMID" "$STATE"
  done

}

project_update()
{
  awx-cli project update -n "$1" $AWX_DEBUG
}

awx_ad_hoc_shell_header()
{
  local INVENTORY LIMIT COMMAND TITLE MSG
  INVENTORY="$1"
  LIMIT="$2"
  COMMAND="$3"
  TITLE="$4"

MSG=$(cat << EOF
## Execute %s in %s" "$TITLE" "$LIMIT"

\`\`\`

  # awx-ad-hoc-shell "$INVENTORY" "$LIMIT" "$COMMAND""

EOF
)

echo "$MSG"

}

awx_ad_hoc_shell_launch()
{
  "$INVENTORY" "$LIMIT" "$COMMAND"
  awx-ad-hoc-shell "$INVENTORY" "$LIMIT" "$COMMAND"
}

awx_ad_hoc_shell_footer()
{
  echo "\\n\`\`\`"
}

awx_ad_hoc_shell()
{
  local INVENTORY LIMIT COMMAND TITLE

awx_ad_hoc_shell_header "$INVENTORY" "$LIMIT" "$COMMAND" "$TITLE"
awx_ad_hoc_shell_launch "$INVENTORY" "$LIMIT" "$COMMAND"
awx_ad_hoc_shell_footer

}

awx_cfg_get()
{
  local TYPE
  TYPE="$(file -b --mime-type "$AWX_CFG")"
  [[ "$TYPE" != 'text/plain' ]] && die "INVALID $AWX_CFG"
  grep "$1" "$AWX_CFG" | cut -d= -f2 | tr -d ' '
}

awx_cfg_read()
{
  AWX_CFG_HOST="$(awx_cfg_get 'host')"
  AWX_CFG_PASS="$(awx_cfg_get 'pass')"
  AWX_CFG_USER="$(awx_cfg_get 'user')"
}

wait_seconds()
{
  local S
  S=5

  [[ -z "$2" ]] || S="$2"

  for i in $(seq "$S" -1 0)
  do
    echo "wait $i seconds to find and send all $1... "
    sleep 1
  done
}

filelist_total()
{
  local TOTAL

  TOTAL="$(wc -l "$1" | cut -d' ' -f1)"
  printf "found %s %s\\n" "$TOTAL" "$2"
}

function json_get_asset_type()
{
  local JSON

  JSON="$1"
  jq -r '.[] | .asset_type' "$JSON" 2>/dev/null

}

function json_is_project()
{
  [[ "$(json_get_asset_type "$1")" = 'project' ]] || return 1
  return 0
}

function json_is_job_template()
{
  [[ "$(json_get_asset_type "$1")" = 'job_template' ]] || return 1
  return 0
}

function json_is_workflow()
{
  [[ "$(json_get_asset_type "$1")" = 'workflow' ]] || return 1
  return 0
}

function json_is_inventory()
{
  [[ "$(json_get_asset_type "$1")" = 'inventory' ]] || return 1
  return 0

}

function get_json()
{
  local JSON
  local NAME
  local NOW
  local BAK

  mkdir -p "$1"
  NAME="$(echo "$2" | tr '/' '-')"
  JSON="$1/$NAME.json"
  NOW="$(date +%s)"
  BAK="$1/$NAME.json.$NOW.bak"

  if [[ -e "$JSON" ]]
  then
    stderror "ALREADY EXISTS $JSON"
    stderror "BACKUP $JSON TO $BAK"
    mv "$JSON" "$BAK"
  fi

  >&2 echo "RECEIVE $JSON"
  awx-cli receive --$1 "$2" > "$JSON"
}

json_get_unified_job_name()
{
  local JQ

  JQ='.[] | .asset_relation | .workflow_nodes | .[] | .unified_job_name'
  jq -r "$JQ" "$1"
}

function json_get_project()
{
  local JQ

  JQ='.[] | .project'
  jq -r "$JQ" "$1"
}

function get_json_workflows()
{
  local TMP
  local N

  N="$(basename "$1" .json)"
  json_get_unified_job_name "$1" | grep "$WORKFLOW_PREFIX" \
    | while read -r i
      do
        json_get_unified_job_name "$DIR_WORKFLOW/$i.json" \
          | grep "$WORKFLOW_PREFIX"  \
          | while read -r j
            do
              json_get_unified_job_name "$DIR_WORKFLOW/$j.json"
              echo "$DIR_WORKFLOW/$j.json"
            done
        echo "$DIR_WORKFLOW/$i.json"
      done
  echo "$DIR_WORKFLOW/$N.json"
}

function get_url()
{
  local P

  [[ "$1" = 'project'      ]] && P='#/projects/'
  [[ "$1" = 'job_template' ]] && P='#/templates/job_template'
  [[ "$1" = 'workflow'     ]] && P='#/templates/workflow_job_template'

  awx_cfg_read

  printf "%s/%s/%s" "$AWX_CFG_HOST" "$P" "$2"
}

project_get_id()
{
  [[ -z "$1" ]] || awx-cli project get -n "$1" -f id
}

job_template_get_id()
{
  [[ -z "$1" ]] || awx-cli job_template get -n "$1" -f id
}

jq_yq_modify()
{
  jq empty "$1" 2>/dev/null

  if [[ "$?" -eq 0 ]]
  then
    jq -r ".$2=\"$3\"" "$1" | sponge "$1"
  else
    yq -r ".$2=\"$3\"" "$1" | sponge "$1"
  fi
}

jq_modify_verbosity()
{
  [[ -e "$1" ]] || die "NOT FOUND $1"
  [[ -z "$2" ]] && die "EMPTY VERBOSITY"

  sed -i "s/\"verbosity\": .,/\"verbosity\": $2,/g" "$1"
}

yaml_host_vars()
{

  printf "%s\\n\\n" '---'
  [[ -z "$1" ]] || printf "ansible_host: %s\\n"        "$1"
  [[ -z "$2" ]] || printf "primary_maccaddress: %s\\n" "$2"
  [[ -z "$3" ]] || printf "hostname: %s\\n"            "$3"
  [[ -z "$4" ]] || printf "inventory_serial: %s\\n"    "$4"

}

ssh_config()
{

  [[ -z "$1" ]] || printf "\\n\\nHost %s %s"       "$1" "$2"
  [[ -z "$3" ]] || printf "\\n     Hostname %s\\n" "$3"

}

config_read()
{

  eval $(sed '/:/!d;/^ *#/d;s/:/ /;' < "$AWX_CONFIG" | while read -r k v
  do
      str="$k='$v'"
      echo "$str"
  done)

  # use proxy
  [[ -z "$HTTP_PROXY" ]] || stderror "Using HTTP_PROXY=$HTTP_PROXY"

}

dependencies_verify()
{

  for i in awx-cli jq yq
  do
    command -v "$i" >/dev/null || die "try: pip install $i " \
      | sed 's/awx-cli/ansibel-tower-cli/g'
  done

}

config_verify()
{

  if [[ ! -e "$AWX_CONFIG" ]]
  then

    if [[ ! "$1" =~ ^[-]+(c|config) ]]
    then
      echo "NOT FOUND FILE: $AWX_CONFIG TRY awx-config -c" && exit 1
    fi

    return 1

  fi

}

main ()
{

  if config_verify "$1"
  then
    dependencies_verify
    config_read
  fi

}

main "$1"