muvazzaf

#!/bin/bash

# Required commands: ansible sponge ssh grep cat gawk sshpass sed
# shellcheck source=/dev/null

trap FinalCleaning EXIT

STR_SUCCESS="Success"
STR_ERROR="ERROR"

APP_DIR="$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")"
test -z "${SCRIPT_DIR}" && SCRIPT_DIR="${APP_DIR}/scripts"
test -z "${COMP_DIR}" && COMP_DIR="${APP_DIR}/components"
test -z "${CACHE_DIR}" && CACHE_DIR="${APP_DIR}/cache"
test -z "${SSH_KEY}" && SSH_KEY="${APP_DIR}/ssh-key"
test -z "${MACHINE_LIST}" && MACHINE_LIST="${APP_DIR}/machine-list"

MACHINE_NUMBER="$(wc -l < "${MACHINE_LIST}")"
ACTIVE_LIST="${CACHE_DIR}/active-machine-list"
PROCESS_ID_LIST="${CACHE_DIR}/proccess-ids"
TIMEOUT_VALUE=5
COMMON_SSH_OPTIONS="-o BatchMode=yes -o StrictHostKeyChecking=no -o ConnectTimeout=${TIMEOUT_VALUE}"

for COMPONENT in "${COMP_DIR}"/*
do
	if [ -f "${COMPONENT}" ]
	then
		source "${COMPONENT}"
	fi
done


function CPUUsage()
{
	cat <(grep 'cpu ' /proc/stat) <(sleep 1 && grep 'cpu ' /proc/stat) | awk -v RS="" '{printf "%.0f\n", ($13-$2+$15-$4)*100/($13-$2+$15-$4+$16-$5)}'
}

function MemoryInfo()
{
	case ${1,,} in
		tenpercentofyourmemory)
			awk '/MemTotal/ {print int($2*0.1)}' /proc/meminfo;;
		available)
			awk '/MemAvailable/ {print $2}' /proc/meminfo;;
	esac
}

function WaitIfSystemResourceIsInsufficient()
{
	while true
	do
		if [ "$(MemoryInfo Available)" -gt "$(MemoryInfo TenPercentOfYourMemory)" ] && [ "$(CPUUsage)" -lt "90" ]
		then
			break
		else
			sleep 5
		fi
	done
}

function ColorEcho()
{
	# shellcheck disable=SC2034
	RED='\e[31m'
	# shellcheck disable=SC2034
	GREEN='\e[32m'
	# shellcheck disable=SC2034
	BLUE='\e[34m'
	# shellcheck disable=SC2034
	YELLOW='\e[1;33m'
	# shellcheck disable=SC2034
	L_BLUE='\e[1;34m'
	# shellcheck disable=SC2034
	NONCOLOR='\e[0m'
	echo -e "${!1}${2}${NONCOLOR}"
}

function CreateNTLMAccessFile()
{
cat > "${1}" << EOF
[windows:vars]
ansible_user=${2}
ansible_password=${3}
ansible_port=5985
ansible_connection=winrm
ansible_winrm_transport=ntlm

[windows]
${4}
EOF
}

function RunCommandViaWinRM()
{
	{ [ -z "${1}" ] || [ -z "${IP}" ] || [ -z "${ACCESS}" ]; } && return 2
	ansible "${IP}" -T "${TIMEOUT_VALUE}" -m win_command -a "powershell -ExecutionPolicy Unrestricted -Command \"${1}\"" -i "${ACCESS}"
}

function RunCommandViaSSH()
{
	{ [ -z "${1}" ] || [ -z "${IP}" ]; } && return 2
	test -z "${PORT}" && local PORT=22
	test -z "${USER}" && local USER=root
	test -z "${PASSWORD}" || local SSHPASS="sshpass -p ${PASSWORD}"
	# shellcheck disable=SC2086
	${SSHPASS} ssh -p "${PORT}" -i "${SSH_KEY}" ${COMMON_SSH_OPTIONS} ${SSH_OPTIONS} "${USER}@${IP}" -- "${1}"
}

function RunLocalScriptRemotelyViaSSH()
{
	{ [ -z "${1}" ] || [ -z "${IP}" ]; } && return 2
	test -z "${PORT}" && local PORT=22
	test -z "${USER}" && local USER=root
	test -z "${PASSWORD}" || local SSHPASS="sshpass -p ${PASSWORD}"
	# shellcheck disable=SC2086
	${SSHPASS} ssh -p "${PORT}" -i "${SSH_KEY}" ${COMMON_SSH_OPTIONS} ${SSH_OPTIONS} "${USER}@${IP}" -- sh -s < "${1}"
}

function CopyFilesViaWinRM()
{
	{ [ -z "${1}" ] || [ -z "${IP}" ] || [ -z "${ACCESS}" ]; } && return 2
	ansible "${IP}" -T "${TIMEOUT_VALUE}" -m win_copy -a "src=${1} dest=${2}" -i "${ACCESS}" > /dev/null 2>&1
}

function CopyFilesViaSSH()
{
	{ [ -z "${1}" ] || [ -z "${IP}" ]; } && return 2
	test -z "${PORT}" && local PORT=22
	test -z "${USER}" && local USER=root
	test -z "${PASSWORD}" || local SSHPASS="sshpass -p ${PASSWORD}"
	# shellcheck disable=SC2086
	${SSHPASS} scp -P "${PORT}" -i "${SSH_KEY}" ${COMMON_SSH_OPTIONS} ${SSH_OPTIONS} "${USER}@${IP}:${1}" "${2}" > /dev/null 2>&1
}

function AddToList()
{
	{ [ -z "${UNIQUE}" ] || [ -z "${ACTIVE_LIST}" ]; } && return 2
	grep -q "^${UNIQUE}$" "${ACTIVE_LIST}" 2>/dev/null || echo "${UNIQUE}" >> "${ACTIVE_LIST}"
}

function CheckLivesViaWinRM()
{
	{ [ -z "${IP}" ] || [ -z "${ACCESS}" ]; } && return 2
	ansible "${IP}" -T "${TIMEOUT_VALUE}" -m win_shell -a "whoami;hostname;(Get-WmiObject win32_operatingsystem).caption;(Get-WmiObject -Class Win32_ComputerSystem).Domain;(Get-ItemProperty HKLM:\SOFTWARE\Microsoft\PowerShell\3\PowerShellEngine).PowerShellVersion" -i "${ACCESS}"
}

function CheckLivesViaSSH()
{
	test -z "${IP}" && return 2
	test -z "${PORT}" && local PORT=22
	test -z "${USER}" && local USER=root
	test -z "${PASSWORD}" || local SSHPASS="sshpass -p ${PASSWORD}"
	# shellcheck disable=SC2086
	${SSHPASS} ssh -p "${PORT}" -i "${SSH_KEY}" ${COMMON_SSH_OPTIONS} ${SSH_OPTIONS} "${USER}@${IP}" -- 'whoami;cat /etc/issue.net;hostname -s;uname -a'
}

function FinalCleaning()
{
	rm -rf "${PROCESS_ID_LIST}"
}

function KeepProcessID()
{
	{ [ -z "${1}" ] || [ -z "${UNIQUE}" ]; } && return 2
	printf "%s,%s\n" "${UNIQUE}" "${1}" >> "${PROCESS_ID_LIST}"
}

function DeleteProcessID()
{
	test -z "${UNIQUE}" && return 2
	test -f "${PROCESS_ID_LIST}" || return 1
	sed -i "/${UNIQUE}/d" "${PROCESS_ID_LIST}"
	sed -i '/^$/d' "${PROCESS_ID_LIST}"
}

function FetchFromMachineList()
{
	# 1 MACHINE LIST LINE NUMBER
	test -z "${1}" && return 2
	sed -n "${1}"p "${MACHINE_LIST}"
}

function ObtainingMachineInformation()
{
	unset UNIQUE IP HNAME MACHINE_TYPE PORT SSH_OPTIONS USER PASSWORD
	UNIQUE="$(sha256sum <<< "${1}" | awk '{print $1}')"
	IP="$(awk -F "," '{print $1}' <<< "${1}")"
	HNAME="$(awk -F "," '{print $2}' <<< "${1}")"
	MACHINE_TYPE="$(awk -F "," '{print $3}' <<< "${1}")"
	PORT="$(awk -F "," '{print $4}' <<< "${1}")"
	SSH_OPTIONS="$(awk -F "," '{print $5}' <<< "${1}")"
	USER="$(awk -F "," '{print $6}' <<< "${1}")"
	PASSWORD="$(awk -F "," '{print $7}' <<< "${1}" | base64 -d)"
}

function Preliminary()
{
	MACHINE_WORK_DIR="${CACHE_DIR}/${UNIQUE}"
	mkdir -p "${MACHINE_WORK_DIR}"

	# Liveness and connectivity checks
	case "${MACHINE_TYPE,,}" in
		windows)
			ACCESS="${MACHINE_WORK_DIR}/access-file"
			CreateNTLMAccessFile "${ACCESS}" "${USER}" "${PASSWORD}" "${IP}"
			CheckLivesViaWinRM > "${MACHINE_WORK_DIR}/output" 2>&1
			local EXIT_CODE=${?}
			# This operation is required to clear the DOS-CRLF output
			dos2unix < "${MACHINE_WORK_DIR}/output" | sponge "${MACHINE_WORK_DIR}/output"
			;;
		linux)
			echo "${IP}" > "${MACHINE_WORK_DIR}/output"
			CheckLivesViaSSH > "${MACHINE_WORK_DIR}/output" 2>&1
			local EXIT_CODE=${?}
			;;
		*)
			return 1
	esac

	if [ ${EXIT_CODE} == 0 ]
	then
		test -f "${MACHINE_WORK_DIR}/output" && mv "${MACHINE_WORK_DIR}/output" "${MACHINE_WORK_DIR}/machine-info"
		AddToList
		test ! -z "${HNAME}" || HNAME="$(sed -n "3p" "${MACHINE_WORK_DIR}/machine-info")"
		test ! -z "${QUERY}" && ColorEcho "GREEN" "${IP}\t${STR_SUCCESS}"
	else
		test -f "${MACHINE_WORK_DIR}/output" && mv "${MACHINE_WORK_DIR}/output" "${MACHINE_WORK_DIR}/machine-error"
		test ! -z "${QUERY}" && ColorEcho "RED" "${IP}\t${STR_ERROR}"
	fi
	
	test ! -z "${QUERY}" && DeleteProcessID

	return ${EXIT_CODE}
}

function StartTask()
{
	case "${MACHINE_TYPE,,}" in
		windows)
			source "${SCRIPT_DIR}/windowstask"
			;;
		linux)
			source "${SCRIPT_DIR}/linuxtask"
			;;
	esac
	
	DeleteProcessID
}

function WaitForProcessesToFinish()
{
	until [ ! -s "${PROCESS_ID_LIST}" ]
	do
		sleep 1
	done
}

function MainProcess()
{
	rm -rf "${CACHE_DIR}" "${ACTIVE_LIST}"
	mkdir -p "${CACHE_DIR}"
	T=1

	if [ "${1,,}" == "query" ]
	then
		QUERY=true
		while [ ${T} -le "${MACHINE_NUMBER}" ]
		do
			WaitIfSystemResourceIsInsufficient
			unset MACHINE_INFO
			local MACHINE_INFO
			MACHINE_INFO="$(FetchFromMachineList "${T}")"
			T=$((T+1))
			ObtainingMachineInformation "${MACHINE_INFO}"
			Preliminary &
			KeepProcessID "${!}"
	        done
	else
		while [ ${T} -le "${MACHINE_NUMBER}" ]
		do
			WaitIfSystemResourceIsInsufficient
			unset MACHINE_INFO
			local MACHINE_INFO
			MACHINE_INFO="$(FetchFromMachineList "${T}")"
			T=$((T+1))
			ObtainingMachineInformation "${MACHINE_INFO}"
			Preliminary || continue
			StartTask &
			KeepProcessID "${!}"
	        done
	fi
	WaitForProcessesToFinish
}

MainProcess "${@}"