#! /bin/bash

# Script pour vérifier la vitesse de la connexion Internet en utilisant speedtest

#########################################################################################################################################################
#
# Centreon Exit Codes
#
# 0	=	OK		    = Le plugin a pu vérifier le service et il semble fonctionner correctement.
# 1	=	Warning		= Le plugin a pu vérifier le service, mais il semblait dépasser un certain seuil d'alerte ou ne pas fonctionner correctement.
# 2	=	Critical	= Le plugin a détecté que le service n'était pas en cours d'exécution ou qu'il dépassait un certain seuil critique
# 3	=	Unknown		= Des arguments de ligne de commande non valides ont été fournis au plugin ou des défaillances de bas niveau internes au plugin
#
########################################################################################################################################################

############ By @tips-of-mine ############
plugin_name="Centreon speedtest plugin"
version="1.0"

#####################################################################
#
#	CHANGELOG
#
#	Version 1.0 - Initial Release
#

#####################################################################

red=$'\033[1;31m'
yellow=$'\033[0;33m'
green=$'\033[0;32m'
nc=$'\033[0m'

# function to output script usage
usage()
{
	cat << EOF
	******************************************************************************************

	$plugin_name - Version: $version

	OPTIONS :
	-h	Afficher ce message
	-w	Niveau d'alerte Warning du téléchargement ${yellow}- *Nécessaire* -${nc} nombre entier ou virgule flottante
	-c	Niveau d'alerte Crtique du téléchargement ${yellow}- *Nécessaire* -${nc} nombre entier ou virgule flottante
	-W	Niveau d'alerte Warning de l'Upload ${yellow}- *Nécessaire* -${nc} nombre entier ou virgule flottante
	-C	Niveau d'alerte Crtique de l'Upload ${yellow}- *Nécessaire* -${nc} nombre entier ou virgule flottante
	-l	Emplacement du serveur speedtest ${yellow}- *Nécessaire * -${nc} 
		Si on mets "a" la selection est automatique.
	-p	Données sur les performances de sortie
	-m	Niveau Download Maximum ${yellow}- *Nécessaire si vous demandez des perfdata* -${nc} nombre entier ou virgule flottante
	-M	Niveau Upload Maximum ${yellow}- *Nécessaire si vous demandez des perfdata* -${nc} nombre entier ou virgule flottante
	-v	Version du plugin
	-V	Informations de débogage pour les tests

	Ce script va envoyer à Centreon la vitesse de la connexion Internet en utilisant speedtest.

	Vous devez d'abord installer speedtest sur votre système.
	https://install.speedtest.net/app/cli/ookla-speedtest-1.2.0-linux-x86_64.tgz

	Voir ici : https://github.com/sivel/speedtest-cli pour des informations sur speedtest

	Tout d'abord, vous DEVEZ définir l'emplacement de votre installation speedtest dans le script, sinon cela ne fonctionnera pas.

	Pour obtenir id d'un serveur réponse faire la commande
	${yellow}./speedtest -L${nc}

	Le speedtest peut prendre un certain temps pour renvoyer son résultat.

	- Vous devez également avoir accès à bc sur votre système pour que ce script fonctionne.
	- Vous devez également avoir accès à jq sur votre système pour que ce script fonctionne.

	Vos niveaux d'alerte doivent être plus élevés que vos niveaux critiques, tant pour le chargement que pour le téléchargement.

	Les données de performance indiquent la vitesse de téléchargement en amont et en aval par rapport aux niveaux d'alerte et aux niveaux critiques correspondants.

	******************************************************************************************
EOF
}

#####################################################################
# Permettant de générer une erreur si l'emplacement binaire du speedtest n'est pas défini
locundef()
{
	cat << EOF
	******************************************************************************************

	$plugin_name - Version: $version
	${red}
	Vous n'avez pas défini l'emplacement du binaire speedtest dans le script !
	Vous DEVEZ le faire le faire avant d'exécuter le script !
	Voir la ligne 149 du script !
	${nc}
	******************************************************************************************
EOF
}

#####################################################################
# Permettant de vérifier si une variable est numérique
# Attend la variable à vérifier comme premier argument
isnumeric()
{
	re='^[0-9]+([.][0-9]+)?$'
	if ! [[ $1 =~ $re ]]; then
		echo "${red}"$2" avec une valeur de : "$1" n'est pas un nombre !${nc}"
		usage
		exit 3
	fi
}

#####################################################################
# Échelle par défaut utilisée par les fonctions flottantes.
float_scale=2

#####################################################################
# Évaluer une expression en virgule flottante.
function float_eval()
{
    local stat=0
    local result=0.0
    if [[ $# -gt 0 ]]; then
	result=$(echo "scale=$float_scale; $*" | bc -q 2>/dev/null)
	stat=$?
	if [[ $stat -eq 0  &&  -z "$result" ]]; then stat=1; fi
    fi
    echo $result
    return $stat
}

#####################################################################
# Évaluer une expression conditionnelle en virgule flottante.
function float_cond()
{
    local cond=0
    if [[ $# -gt 0 ]]; then
	cond=$(echo "$*" | bc -q 2>/dev/null)
	if [[ -z "$cond" ]]; then cond=0; fi
	if [[ "$cond" != 0  &&	"$cond" != 1 ]]; then cond=0; fi
    fi
    local stat=$((cond == 0))
    return $stat
}

# Configurer la variable pour l'emplacement du binaire speedtest.
# Modifiez la ligne ci-dessous pour que la variable soit définie comme l'emplacement de speedtest sur votre système
# Sur le mien, il s'agit de /usr/lib/centreon/plugins . 
# Veillez à ce que la dernière barre oblique soit supprimée !
# Vous DEVEZ définir cette variable, sinon le script ne s'exécutera pas !
STb=/usr/lib/centreon/plugins

# Configurer les variables pour qu'elles prennent en compte les arguments
DLw=
DLc=
ULw=
ULc=
Loc=
PerfData=
MaxDL=
MaxUL=
debug=

# Recuperer les arguments a l aide de getopts
while getopts "h:w:c:W:C:l:p:m:M:vV" OPTION
do
	case $OPTION in
	h)
		usage
		exit 3
		;;
	w)
		DLw=$OPTARG
		;;
	c)
		DLc=$OPTARG
		;;
	W)
		ULw=$OPTARG
		;;
	C)
		ULc=$OPTARG
		;;
	l)
		Loc=$OPTARG
		;;
	p)
		PerfData="TRUE"
		;;
        m)
		MaxDL=$OPTARG
                ;;
        M)
		MaxUL=$OPTARG
                ;;
	v)
		echo "$plugin_name. Numero de version : $version"
		exit 3
		;;
	V)
		debug="TRUE"
		;;
esac
done

# Vérifie si la variable binaire Speedtest $STb a été définie
# Quitte avec un avertissement si ce n'est pas le cas.
if [[ -z $STb ]]
then
	locundef
	exit 3
fi

# Vérifier si les arguments sont vides
# Quitte avec un avertissement si ce n'est pas le cas.
if  [[ -z $DLw ]] || [[ -z $DLc ]] || [[ -z $ULw ]] || [[ -z $ULc ]] || [[ -z $Loc ]]
then
	usage
	exit 3
fi

# Vérifier si les arguments maximums de téléchargement et d'envoi sont vides si des données de performance ont été demandées.
if [ "$PerfData" == "TRUE" ]
then
        if [[ -z $MaxDL ]] || [[ -z $MaxUL ]]
	then
		echo "2"
		usage
		exit 3
        fi
fi

# Vérification des arguments non numériques
isnumeric $DLw "Niveau Download Warning"
isnumeric $DLc "Niveau Download Critical"
isnumeric $ULw "Niveau Upload Warning"
isnumeric $ULc "Niveau Upload Critical"

# Vérifier les maximums d'upload et de download uniquement si des données de performance sont demandées.
if [ "$PerfData" == "TRUE" ]; then
	isnumeric $MaxDL "Niveau Download Maximum "
	isnumeric $MaxUL "Niveau Upload Maximum"
fi

# Vérifier si le binaire bc et jq  sont installés
type bc >/dev/null 2>&1 || { echo >&2 "${red}Veuillez installer bc binary (pour effectuer des opérations en virgule flottante)${nc}"; exit 3; }
type jq >/dev/null 2>&1 || { echo >&2 "${red}Veuillez installer jq binary (pour l'analyse du json)${nc}"; exit 3; }

# Vérifier que les niveaux d'alerte ne sont pas inférieurs aux niveaux critiques
if float_cond "$DLw < $DLc"; then
	echo "${red} \$DLw est inférieur à \$DLc !${nc}"
	usage
	exit 3
elif float_cond "$ULw < $ULc"; then
	echo "${red} \$ULw est inférieur à \$ULc ! ${nc}"
	usage
	exit 3
fi

# Arguments de sortie pour le débogage
if [ "$debug" == "TRUE" ]; then
	echo "${yellow}*-*-*-*-*-*-*-*-*-*-"
	echo "* DEBUG MODE"
	echo "*-*-*-*-*-*-*-*-*-*-${nc}"

	echo "Download Warning Level  = ${green}"$DLw${nc}
	echo "Download Critical Level = ${green}"$DLc${nc}
	echo "Upload Warning Level    = ${green}"$ULw${nc}
	echo "Upload Critical Level   = ${green}"$ULc${nc}
	echo "Server Location         = ${green}"$Loc${nc}
fi

# Configurer la commande en fonction du choix d'un serveur cible automatique ou non
if [ "$Loc" == "a" ]; then
	if [ "$debug" == "TRUE" ]; then
		echo " Mode automatique"
	fi
	command=$($STb/speedtest --unit GB/s --format=json --accept-license --accept-gdpr)
else
	if [ "$debug" == "TRUE" ]; then
		echo " Avec un serveur cible definie"
	fi
	command=$($STb/speedtest --server-id=$Loc --unit GB/s --format=json --accept-license --accept-gdpr)
fi

# 
typeset -a array

array=($command)

# Definition des fichiers de travail
speedtest_tempfile="/tmp/speedtest-tmp.json"
speedtest_file="/tmp/speedtest.json"

# Sauvegarde du fichier temporaire
cat <<EOF > ${speedtest_tempfile}
${array[@]}
EOF

# Mise en format json
good=$(cat ${speedtest_tempfile} | jq .)

# Sauvegarde du fichier final
cat <<EOF > ${speedtest_file}
${good}
EOF

# 
typeset -a reply_JITTER
typeset -a reply_LATENCY
typeset -a reply_LOW
typeset -a reply_HIGH
typeset -a reply_DOWNLOAD_BANDWIDTH
typeset -a reply_UPLOAD_BANDWIDTH
typeset -a reply_PACKETLOSS

# Récupération de variable dans le fichiers json
JITTER=$(cat ${speedtest_file} | grep jitter | cut -f2 -d":" | sed 's/,/\n/g' | head -n 1 | cut -c 2- )
LATENCY=$(cat ${speedtest_file} | grep latency | cut -f2 -d":" | sed 's/,/\n/g' | head -n 1 | cut -c 2- )
LOW=$(cat ${speedtest_file} | grep low | cut -f2 -d":" | sed 's/,/\n/g' | head -n 1 | cut -c 2- )
HIGH=$(cat ${speedtest_file} | grep high | cut -f2 -d":" | sed 's/,/\n/g' | head -n 1 | cut -c 2- )
DOWNLOAD_BANDWIDTH_tmp=$(cat ${speedtest_file} | grep bandwidth | cut -f2 -d":" | sed 's/,/\n/g' | head -n 1 | cut -c 2- )
UPLOAD_BANDWIDTH_tmp=$(cat ${speedtest_file} | grep bandwidth | cut -f2 -d":" | sed 's/,/\n/g' | sed -n '3 p' | cut -c 2- )
PACKETLOSS=$(cat ${speedtest_file} | grep packetLoss | cut -f2 -d":" | sed 's/,/\n/g' | head -n 1 | cut -c 2- )
ISP=$(cat ${speedtest_file} | grep isp | cut -f2 -d":" | sed 's/,/\n/g ; s/"//g' | head -n 1 | cut -c 2- )
EXTERNALIP=$(cat ${speedtest_file} | grep externalIp | cut -f2 -d":" | sed 's/,/\n/g ; s/"//g' | head -n 1 | cut -c 2- )
HOST=$(cat ${speedtest_file} | grep host | cut -f2 -d":" | sed 's/,/\n/g ; s/"//g' | head -n 1 | cut -c 2- )
NAME=$(cat ${speedtest_file} | grep name | cut -f2 -d":" | sed 's/,/\n/g ; s/"//g' | head -n 3 | sed -n '3 p' | cut -c 2- )
LOCATION=$(cat ${speedtest_file} | grep location | cut -f2 -d":" | sed 's/,/\n/g ; s/"//g' | head -n 1 | cut -c 2- )
COUNTRY=$(cat ${speedtest_file} | grep country | cut -f2 -d":" | sed 's/,/\n/g ; s/"//g' | head -n 1 | cut -c 2- )
IPHOST=$(cat ${speedtest_file} | grep ip | cut -f2 -d":" | sed 's/,/\n/g ; s/"//g' | head -n 1 | cut -c 2- )

# Convertion de la valeur
valeur="0.000008"
DOWNLOAD_BANDWIDTH=$(echo "${DOWNLOAD_BANDWIDTH_tmp[0]}*${valeur}/1" | bc)
UPLOAD_BANDWIDTH=$(echo "${UPLOAD_BANDWIDTH_tmp[0]}*${valeur}/1" | bc)

#
if [ "$debug" == "TRUE" ]; then
	echo "${yellow}*-*-*-*-*-*-*-*-*-*-"
	echo "* DEBUG MODE"
	echo "*-*-*-*-*-*-*-*-*-*-${nc}"

	echo "Ping"
	echo "Jitter                   = ${green}${JITTER[0]}${nc}"
	echo "Latency                  = ${green}${LATENCY[0]}${nc}"
	echo "Low                      = ${green}${LOW[0]}${nc}"
	echo "High                     = ${green}${HIGH[0]}${nc}"
	echo "Download"
	echo "Download bandwidth       = ${green}${DOWNLOAD_BANDWIDTH}${nc}"
	echo "Upload"
	echo "Upload bandwidth         = ${green}${UPLOAD_BANDWIDTH}${nc}"
	echo "PacketLoss               = ${green}${PACKETLOSS[0]}${nc}"
	echo "information"
	echo "ISP                      = ${green}${ISP[0]}${nc}"
	echo "EXTERNAL IP              = ${green}${EXTERNALIP[0]}${nc}"
	echo "Host                     = ${green}${HOST[0]}${nc}"
	echo "Name                     = ${green}${NAME[0]}${nc}"
	echo "Location                 = ${green}${LOCATION[0]}${nc}"
	echo "Country                  = ${green}${COUNTRY[0]}${nc}"
	echo "IP HOST                  = ${green}${IPHOST[0]}${nc}"
fi

# Variables unité pour affichage
pingUOM="ms"
downloadUOM="Mbit/s"
uploadUOM="Mbit/s"

rm -f ${speedtest_tempfile}
rm -f ${speedtest_file}

# Configurer les variables de statut et de code de sortie
status=
code=

# Nous vérifions maintenant si les valeurs renvoyées se situent dans les fourchettes définies.
if float_cond "$download < $DLc"; then
	if [ "$debug" == "TRUE" ]; then
		echo "${yellow}*-*-*-*-*-*-*-*-*-*-"
		echo "* DEBUG MODE"
		echo "*-*-*-*-*-*-*-*-*-*-${nc}"

		echo "Télécharger moins que la limite critique. ${green}${download}${nc} = ${green}${download}${nc} et ${green}${DLc} = ${green}${DLc}${nc} "
	fi
	status="CRITICAL"
	code=2
elif float_cond "$upload < $ULc"; then
	if [ "$debug" == "TRUE" ]; then
		echo "${yellow}*-*-*-*-*-*-*-*-*-*-"
		echo "* DEBUG MODE"
		echo "*-*-*-*-*-*-*-*-*-*-${nc}"

		echo "Upload inférieur à la limite critique. ${green}${upload}${nc} = ${green}${upload}${nc} et ${green}${ULc}${nc} = ${green}${ULc}${nc}"
	fi
	status="CRITICAL"
	code=2
elif float_cond "$download < $DLw"; then
	if [ "$debug" == "TRUE" ]; then
		echo "${yellow}*-*-*-*-*-*-*-*-*-*-"
		echo "* DEBUG MODE"
		echo "*-*-*-*-*-*-*-*-*-*-${nc}"

		echo "Téléchargement inférieur à la limite d'avertissement. ${green}${download}${nc} = ${green}${download}${nc} et ${green}${DLw}${nc} = ${green}${DLw}${nc}"
	fi
	status="WARNING"
	code=1
elif float_cond "$upload < $ULw"; then
	if [ "$debug" == "TRUE" ]; then
		echo "${yellow}*-*-*-*-*-*-*-*-*-*-"
		echo "* DEBUG MODE"
		echo "*-*-*-*-*-*-*-*-*-*-${nc}"

		echo "Upload inférieur à la limite d'avertissement. ${green}${upload}${nc} = ${green}${upload}${nc} et ${green}${ULw}${nc} = ${green}${ULw}${nc}"
	fi
	status="WARNING"
	code=1
else
	if [ "$debug" == "TRUE" ]; then
		echo "${yellow}*-*-*-*-*-*-*-*-*-*-"
		echo "* DEBUG MODE"
		echo "*-*-*-*-*-*-*-*-*-*-${nc}"

		echo "Tout est correct !"
	fi
	status="OK"
	code=0
fi

out="$status - Ping = ${LATENCY[0]} $pingUOM Paquet perdu = ${PACKETLOSS[0]} Download = ${DOWNLOAD_BANDWIDTH[0]} $downloadUOM Upload = ${UPLOAD_BANDWIDTH[0]} $uploadUOM"

# append perfout if argument was passed to script
if [ "$PerfData" == "TRUE" ]; then
	if [ "$debug" == "TRUE" ]; then
		echo "${yellow}*-*-*-*-*-*-*-*-*-*-"
		echo "* DEBUG MODE"
		echo "*-*-*-*-*-*-*-*-*-*-${nc}"

		echo "PerfDonnees demandees !"
	fi
	perfout="|'latency'=${LATENCY[0]} 'packetloss'=${PACKETLOSS[0]} 'download'=${DOWNLOAD_BANDWIDTH[0]};${DLw};${DLc};0;$(echo $MaxDL*1.05|bc) 'upload'=${UPLOAD_BANDWIDTH[0]};$ULw;$ULc;0;$(echo $MaxUL*1.05|bc)"
	out=$out$perfout
fi

echo $out
exit $code