verdnatura/monitoring-plugins-vn
verdnatura
/
monitoring-plugins-vn
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Plugins updated

This commit is contained in:
Juan Ferrer 2024-10-20 11:54:28 +02:00
parent b122be4301
commit ffca5a9a31
23 changed files with 406 additions and 734 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
README.md
View File

@ -1,2 +1,3 @@
# CUSTOM NAGIOS CHECK PLUGINS
In this repo , you can find custom checks plugins for Nagios , developed in bash or python.
# Verdnatura Nagios plugins
Collection of custom plugins used by Verdnatura.

28
check_backup/v1/check_backup.py
View File

@ -1,28 +0,0 @@
#!/usr/bin/env python3
###########################
# Estado: En progreso #
# Author: Rubenb #
# Fecha: 04/01/2024 #
###########################
import subprocess
import os
import sys
from datetime import datetime
def verificar_backup():
# lógica para verificar archivos de backup con la fecha de hoy
directorio_backup = "/srv/tftp/backup"
fecha_hoy = datetime.now().strftime('%Y%m%d')
archivos_backup = [f for f in os.listdir(directorio_backup) if f.endswith('.bak') and f.startswith(fecha_hoy)]
if archivos_backup:
mensaje = "Archivos de backup de hoy encontrados: " + ', '.join(archivos_backup)
print("OK:", mensaje)
sys.exit(0) # OK
else:
mensaje = "No se encontraron archivos de backup de hoy."
print("CRITICAL:", mensaje)
sys.exit(2) # Critical
verificar_backup()

80
check_backup/v1/check_backup_cisco.py
View File

@ -1,80 +0,0 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
###########################
# Author: Rubenb #
# Fecha: 04/01/2024 #
###########################
import subprocess
import os
import sys
from datetime import datetime
def verificar_backup():
# Lista de nombres de archivos específicos
nombres_archivos = ["sw19", "sw20", "sw21", "hol-sw1"]
# Variable fecha actual
fecha_actual = datetime.now().strftime('%Y%m%d')
# Variable directorio backups
directorio_backup = "/srv/tftp/backup"
# archivos que deberian existir running config
archivos_deberian_existir_running_config = [nombre + '-running-config-' + fecha_actual for nombre in nombres_archivos if nombre + '-running-config-' + fecha_actual ]
# archivos que deberian existir boot
archivos_deberian_existir_boot = [nombre + '-boot-' + fecha_actual for nombre in nombres_archivos if nombre + '-boot-' + fecha_actual ]
# lista concatenada archivos_deberian_existir running_config + boot
lista_concatenada_archivos_deberian_existir = archivos_deberian_existir_running_config + archivos_deberian_existir_boot
# debug deberian existir running config
#print("archivosQueDeberianExistir _running_config:", archivos_deberian_existir_running_config) # debug
# debug deberian existir boot
#print("archivosQueDeberianExistir _boot:", archivos_deberian_existir_boot) # debug
# debug lista concatenada archivos_deberian_existir running_config + boot
#print("archivos_deberian_existir running_config + boot:", lista_concatenada_archivos_deberian_existir) # debug
# archivos encontrados / existentes _running_config
archivos_encontrados_running_config = [nombre + '-running-config-' + fecha_actual for nombre in nombres_archivos if nombre + '-running-config-' + fecha_actual in os.listdir(directorio_backup)]
# archivos encontrados / existentes _boot
archivos_encontrados_boot = [nombre + '-boot-' + fecha_actual for nombre in nombres_archivos if nombre + '-boot-' + fecha_actual in os.listdir(directorio_backup)]
# lista concatenada archivos encontrados / existentes running_config + boot
lista_concatenada_archivos_encontrados = archivos_encontrados_running_config + archivos_encontrados_boot
# debug archivos encontrados / existentes _running_config
#print("archivosEncontrados:", archivos_encontrados_running_config) # debug
# debug archivos encontrados / existentes _boot
#print("archivosEncontrados:", archivos_encontrados_boot) # debug
# debug lista concatenada archivos encontrados / existentes running_config + boot
#print("archivosEncontrados running_config + boot:", lista_concatenada_archivos_encontrados) # debug
# archivos no encontrados / no existentes _running_config
archivos_no_encontrados_running_config = [nombre + '-running-config-' + fecha_actual for nombre in nombres_archivos if nombre + '-running-config-' + fecha_actual not in os.listdir(directorio_backup)]
# archivos no encontrados / no existentes _boot
archivos_no_encontrados_boot = [nombre + '-boot-' + fecha_actual for nombre in nombres_archivos if nombre + '-boot-' + fecha_actual not in os.listdir(directorio_backup)]
# lista concatenada archivos encontrados / existentes running_config + boot
lista_concatenada_archivos_no_encontrados = archivos_no_encontrados_running_config + archivos_no_encontrados_boot
# debug archivos no encontrados / no existentes _running_config
#print("archivosNoEncontrados_running_config:", archivos_no_encontrados_running_config) # debug
# debug archivos no encontrados / no existentes _boot
#print("archivosNoEncontrados_boot:", archivos_no_encontrados_boot) # debug
# debug lista concatenada archivos no encontrados / no existentes running_config + boot
#print("archivosNoEncontrados running_config + boot:", lista_concatenada_archivos_no_encontrados) # debug
# lógica para verificar la existencia de archivos específicos para la fecha de hoy
if lista_concatenada_archivos_deberian_existir != lista_concatenada_archivos_encontrados:
mensaje = f"No se encontraron archivos de backup para la fecha {fecha_actual} o falta alguno , archivos encontrados {lista_concatenada_archivos_encontrados} , archivos que deberian existir {lista_concatenada_archivos_deberian_existir} , Archivos no encontrados: {lista_concatenada_archivos_no_encontrados} , Revisar backups en /srv/tftp/backup ."
print("CRITICAL:", mensaje)
sys.exit(2) # Critical
else:
mensaje = f"Archivos de backup encontrados {', '.join(lista_concatenada_archivos_encontrados)} ."
print("OK:", mensaje)
sys.exit(0) # OK
verificar_backup()

50
check_backup/v1/check_backup_huawei.py
View File

@ -1,50 +0,0 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
###########################
# Author: Rubenb #
# Fecha: 04/01/2024 #
###########################
import subprocess
import os
import sys
from datetime import datetime
def verificar_backup():
# Lista de nombres de archivos específicos
nombres_archivos = ["sw1", "sw2", "sw3", "sw5", "sw6", "sw7", "sw8", "sw9", "sw10", "sw11", "sw12", "sw13", "sw14", "sw15", "sw16", "sw18", "sw24"]
# Variable fecha actual
fecha_actual = datetime.now().strftime('%Y%m%d')
# Variable directorio backups
directorio_backup = "/srv/tftp/backup"
# archivos que deberian existir
archivos_deberian_existir = [nombre + '-vrpcfg-' + fecha_actual + '.zip' for nombre in nombres_archivos if nombre + '-vrpcfg-' + fecha_actual + '.zip']
# debug
#print("archivosQueDeberianExistir:", archivos_deberian_existir) # debug
# archivos encontrados / existentes
archivos_encontrados = [nombre + '-vrpcfg-' + fecha_actual + '.zip' for nombre in nombres_archivos if nombre + '-vrpcfg-' + fecha_actual + '.zip' in os.listdir(directorio_backup)]
# archivos no encontrados / no existentes
archivos_no_encontrados = [nombre + '-vrpcfg-' + fecha_actual + '.zip' for nombre in nombres_archivos if nombre + '-vrpcfg-' + fecha_actual + '.zip' not in os.listdir(directorio_backup)]
# debug
#print("archivosEncontrados:", archivos_encontrados) # debug
# debug
#print("archivosNoEncontrados:", archivos_no_encontrados) # debug
# lógica para verificar la existencia de archivos específicos para la fecha de hoy
if archivos_deberian_existir != archivos_encontrados:
mensaje = f"No se encontraron archivos de backup para la fecha {fecha_actual} o falta alguno , archivos encontrados {archivos_encontrados} , archivos que deberian existir {archivos_deberian_existir} , Archivos no encontrados: {archivos_no_encontrados} , Revisar backups en /srv/tftp/backup ."
print("CRITICAL:", mensaje)
sys.exit(2) # Critical
else:
mensaje = f"Archivos de backup encontrados {', '.join(archivos_encontrados)} ."
print("OK:", mensaje)
sys.exit(0) # OK
verificar_backup()

77
check_backup/v1/check_backup_mikrotik.py
View File

@ -1,77 +0,0 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
###########################
# Author: Rubenb #
# Fecha: 04/01/2024 #
###########################
import subprocess
import os
import sys
from datetime import datetime
def verificar_backup():
# Lista de nombres de archivos específicos
nombres_archivos = ["madrid", "holland"]
# Variable fecha actual
fecha_actual = datetime.now().strftime('%Y%m%d')
# Variable directorio backups
directorio_backup = "/srv/tftp/backup"
# archivos backup que deberian existir
archivos_backup_deberian_existir = [nombre + '-backup-' + fecha_actual + '.backup' for nombre in nombres_archivos if nombre + '-backup-' + fecha_actual + '.backup']
# debug
#print("archivosQueDeberianExistir:", archivos_backup_deberian_existir) # debug
# archivos backupscript que deberian existir
archivos_backupscript_deberian_existir = [nombre + '-backupscript-' + fecha_actual + '.rsc' for nombre in nombres_archivos if nombre + '-backupscript-' + fecha_actual + '.rsc']
# debug
#print("archivosQueDeberianExistir:", archivos_backupscript_deberian_existir) # debug
# lista concatenada archivos_deberian_existir backup + backupscript
lista_concatenada_archivos_deberian_existir = archivos_backup_deberian_existir + archivos_backupscript_deberian_existir
# archivos backup encontrados / existentes
archivos_backup_encontrados = [nombre + '-backup-' + fecha_actual + '.backup' for nombre in nombres_archivos if nombre + '-backup-' + fecha_actual + '.backup' in os.listdir(directorio_backup)]
# debug
#print("archivosEncontrados:", archivos_backup_encontrados) # debug
# archivos backupscript encontrados / existentes
archivos_backupscript_encontrados = [nombre + '-backupscript-' + fecha_actual + '.rsc' for nombre in nombres_archivos if nombre + '-backupscript-' + fecha_actual + '.rsc' in os.listdir(directorio_backup)]
# debug
#print("archivosEncontrados:", archivos_backupscript_encontrados) # debug
# lista concatenada archivos_encontrados backup + backupscript
lista_concatenada_archivos_encontrados = archivos_backup_encontrados + archivos_backupscript_encontrados
# archivos backup no encontrados / existentes
archivos_backup_no_encontrados = [nombre + '-backup-' + fecha_actual + '.backup' for nombre in nombres_archivos if nombre + '-backup-' + fecha_actual + '.backup' not in os.listdir(directorio_backup)]
# debug
#print("archivosbackupNoEncontrados:", archivos_backup_no_encontrados) # debug
# archivos backupscript no encontrados / existentes
archivos_backupscript_no_encontrados = [nombre + '-backupscript-' + fecha_actual + '.rsc' for nombre in nombres_archivos if nombre + '-backupscript-' + fecha_actual + '.rsc' not in os.listdir(directorio_backup)]
# debug
#print("archivosbackupscriptNoEncontrados:", archivos_backupscript_no_encontrados) # debug
# lista concatenada archivos_no_encontrados backup + backupscript
lista_concatenada_archivos_no_encontrados = archivos_backup_no_encontrados + archivos_backupscript_no_encontrados
# lógica para verificar la existencia de archivos específicos para la fecha de hoy
if lista_concatenada_archivos_deberian_existir != lista_concatenada_archivos_encontrados:
mensaje = f"No se encontraron archivos de backup para la fecha {fecha_actual} o falta alguno , archivos encontrados {lista_concatenada_archivos_encontrados} , archivos que deberian existir {lista_concatenada_archivos_deberian_existir} , Archivos no encontrados: {lista_concatenada_archivos_no_encontrados} , Revisar backups en /srv/tftp/backup ."
print("CRITICAL:", mensaje)
sys.exit(2) # Critical
else:
mensaje = f"Archivos de backup encontrados {', '.join(lista_concatenada_archivos_encontrados)} ."
print("OK:", mensaje)
sys.exit(0) # OK
verificar_backup()

50
check_backup/v1/check_backup_opnsense.py
View File

@ -1,50 +0,0 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
###########################
# Author: Rubenb #
# Fecha: 04/01/2024 #
###########################
import subprocess
import os
import sys
from datetime import datetime
def verificar_backup():
# Lista de nombres de archivos específicos
nombres_archivos = ["gw1"]
# Variable fecha actual
fecha_actual = datetime.now().strftime('%Y%m%d')
# Variable directorio backups
directorio_backup = "/srv/tftp/backup"
# archivos que deberian existir
archivos_deberian_existir = [nombre + '-config-' + fecha_actual for nombre in nombres_archivos if nombre + '-config-' + fecha_actual]
# debug
#print("archivosQueDeberianExistir:", archivos_deberian_existir) # debug
# archivos encontrados / existentes
archivos_encontrados = [nombre + '-config-' + fecha_actual for nombre in nombres_archivos if nombre + '-config-' + fecha_actual in os.listdir(directorio_backup)]
# debug
#print("archivosEncontrados:", archivos_encontrados) # debug
# archivos no encontrados / no existentes
archivos_no_encontrados = [nombre + '-config-' + fecha_actual for nombre in nombres_archivos if nombre + '-config-' + fecha_actual not in os.listdir(directorio_backup)]
# debug
#print("archivosNoEncontrados:", archivos_no_encontrados) # debug
# lógica para verificar la existencia de archivos específicos para la fecha de hoy
if archivos_deberian_existir != archivos_encontrados:
mensaje = f"No se encontraron archivos de backup para la fecha {fecha_actual} o falta alguno , archivos encontrados {archivos_encontrados} , archivos que deberian existir {archivos_deberian_existir} , Archivos no encontrados: {archivos_no_encontrados} , Revisar backups en /srv/tftp/backup ."
print("CRITICAL:", mensaje)
sys.exit(2) # Critical
else:
mensaje = f"Archivos de backup encontrados {', '.join(archivos_encontrados)} ."
print("OK:", mensaje)
sys.exit(0) # OK
verificar_backup()

37
check_backup/v2/check_backup_base_v2.py
View File

@ -1,37 +0,0 @@
#!/usr/bin/env python3
import os
import datetime
import sys
def check_backups(directory, filenames):
# Obtener la fecha actual en formato año-mes-día
today = datetime.datetime.now().strftime("%Y-%m-%d")
missing_files = []
# Comprobar todos los archivos esperados
for base_name in filenames:
expected_filename = f"{base_name}-{today}.tar.gz"
full_path = os.path.join(directory, expected_filename)
if not os.path.exists(full_path):
missing_files.append(expected_filename)
if missing_files:
print(f"CRITICAL: Missing backup files in {directory}: " + ", ".join(missing_files))
return 2 # Código de salida para CRITICAL
print("OK: All backup files exist.")
return 0 # Código de salida para OK
if __name__ == "__main__":
# Chequear si se proporcionaron suficientes argumentos
if len(sys.argv) < 3:
print("Usage: {} <directory> <filename1> [<filename2> ...]".format(sys.argv[0]))
sys.exit(3) # Código de salida para UNKNOWN
backup_directory = sys.argv[1]
filenames = sys.argv[2:]
# Llamar a la función de comprobación y salir con el código de estado adecuado
result = check_backups(backup_directory, filenames)
sys.exit(result)

37
check_backup/v2/check_backup_cisco_v2.py
View File

@ -1,37 +0,0 @@
#!/usr/bin/env python3
import os
import datetime
import sys
def check_backups(directory, filenames):
# Obtener la fecha actual en formato año-mes-día
today = datetime.datetime.now().strftime("%Y%m%d")
missing_files = []
# Comprobar todos los archivos esperados
for base_name in filenames:
expected_filename = f"{base_name}-{today}"
full_path = os.path.join(directory, expected_filename)
if not os.path.exists(full_path):
missing_files.append(expected_filename)
if missing_files:
print(f"CRITICAL: Missing backup files in {directory}: " + ", ".join(missing_files))
return 2 # Código de salida para CRITICAL
print("OK: All backup files exist.")
return 0 # Código de salida para OK
if __name__ == "__main__":
# Chequear si se proporcionaron suficientes argumentos
if len(sys.argv) < 3:
print("Usage: {} <directory> <filename1> [<filename2> ...]".format(sys.argv[0]))
sys.exit(3) # Código de salida para UNKNOWN
backup_directory = sys.argv[1]
filenames = sys.argv[2:]
# Llamar a la función de comprobación y salir con el código de estado adecuado
result = check_backups(backup_directory, filenames)
sys.exit(result)

37
check_backup/v2/check_backup_huawei_v2.py
View File

@ -1,37 +0,0 @@
#!/usr/bin/env python3
import os
import datetime
import sys
def check_backups(directory, filenames):
# Obtener la fecha actual en formato año-mes-día
today = datetime.datetime.now().strftime("%Y%m%d")
missing_files = []
# Comprobar todos los archivos esperados
for base_name in filenames:
expected_filename = f"{base_name}-{today}.zip"
full_path = os.path.join(directory, expected_filename)
if not os.path.exists(full_path):
missing_files.append(expected_filename)
if missing_files:
print(f"CRITICAL: Missing backup files in {directory}: " + ", ".join(missing_files))
return 2 # Código de salida para CRITICAL
print("OK: All backup files exist.")
return 0 # Código de salida para OK
if __name__ == "__main__":
# Chequear si se proporcionaron suficientes argumentos
if len(sys.argv) < 3:
print("Usage: {} <directory> <filename1> [<filename2> ...]".format(sys.argv[0]))
sys.exit(3) # Código de salida para UNKNOWN
backup_directory = sys.argv[1]
filenames = sys.argv[2:]
# Llamar a la función de comprobación y salir con el código de estado adecuado
result = check_backups(backup_directory, filenames)
sys.exit(result)

37
check_backup/v2/check_backup_huawei_wireless-controller_v2.py
View File

@ -1,37 +0,0 @@
#!/usr/bin/env python3
import os
import datetime
import sys
def check_backups(directory, filenames):
# Obtener la fecha actual en formato año-mes-día
today = datetime.datetime.now().strftime("%Y%m%d")
missing_files = []
# Comprobar todos los archivos esperados
for base_name in filenames:
expected_filename = f"{base_name}-{today}.zip"
full_path = os.path.join(directory, expected_filename)
if not os.path.exists(full_path):
missing_files.append(expected_filename)
if missing_files:
print(f"CRITICAL: Missing backup files in {directory}: " + ", ".join(missing_files))
return 2 # Código de salida para CRITICAL
print("OK: All backup files exist.")
return 0 # Código de salida para OK
if __name__ == "__main__":
# Chequear si se proporcionaron suficientes argumentos
if len(sys.argv) < 3:
print("Usage: {} <directory> <filename1> [<filename2> ...]".format(sys.argv[0]))
sys.exit(3) # Código de salida para UNKNOWN
backup_directory = sys.argv[1]
filenames = sys.argv[2:]
# Llamar a la función de comprobación y salir con el código de estado adecuado
result = check_backups(backup_directory, filenames)
sys.exit(result)

55
check_backup/v2/check_backup_mikrotik_v2.py
View File

@ -1,55 +0,0 @@
#!/usr/bin/env python3
import os
import datetime
import sys
def check_backups(directory, filenames, extensions):
# Obtener la fecha actual en formato año-mes-día
today = datetime.datetime.now().strftime("%Y%m%d")
missing_files = []
# lista de nombres de archivos a excluir de la comprobacion
excluded_files_one = ["holland-backupscript", "madrid-backupscript", "barcelona-backupscript"]
excluded_files_two = ["holland-backup", "madrid-backup", "barcelona-backup"]
# Lista de nombres de archivo a excluir que NO existen ej. holland-backupscript-fecha.backup
excluded_names_one = [f"{file_name}-{today}.backup" for file_name in excluded_files_one]
# Lista de nombres de archivo a excluir que NO existen ej. holland-backup-fecha.backup
excluded_names_two = [f"{file_name}-{today}.rsc" for file_name in excluded_files_two]
# Suma de arrays con lista de nombres de archivos a excluir
excluded_names = excluded_names_one + excluded_names_two
# Comprobar todos los archivos esperados
for base_name in filenames:
for extension in extensions:
expected_filename = f"{base_name}-{today}.{extension}"
# si el nombre base esta en la lista de nombres excluidos , continuar con el siguiente nombre
if expected_filename in excluded_names:
continue
full_path = os.path.join(directory, expected_filename)
if not os.path.exists(full_path):
missing_files.append(expected_filename)
if missing_files:
print(f"CRITICAL: Missing backup files in {directory}: " + ", ".join(missing_files))
return 2 # Código de salida para CRITICAL
print("OK: All backup files exist.")
return 0 # Código de salida para OK
if __name__ == "__main__":
# Chequear si se proporcionaron suficientes argumentos
if len(sys.argv) < 3:
print("Usage: {} <directory> <filename1> [<filename2> ...]".format(sys.argv[0]))
sys.exit(3) # Código de salida para UNKNOWN
backup_directory = sys.argv[1]
filenames = sys.argv[2:]
extensions = ['rsc', 'backup']
# Llamar a la función de comprobación y salir con el código de estado adecuado
result = check_backups(backup_directory, filenames, extensions)
sys.exit(result)

37
check_backup/v2/check_backup_opnsense_v2.py
View File

@ -1,37 +0,0 @@
#!/usr/bin/env python3
import os
import datetime
import sys
def check_backups(directory, filenames):
# Obtener la fecha actual en formato año-mes-día
today = datetime.datetime.now().strftime("%Y%m%d")
missing_files = []
# Comprobar todos los archivos esperados
for base_name in filenames:
expected_filename = f"{base_name}-{today}"
full_path = os.path.join(directory, expected_filename)
if not os.path.exists(full_path):
missing_files.append(expected_filename)
if missing_files:
print(f"CRITICAL: Missing backup files in {directory}: " + ", ".join(missing_files))
return 2 # Código de salida para CRITICAL
print("OK: All backup files exist.")
return 0 # Código de salida para OK
if __name__ == "__main__":
# Chequear si se proporcionaron suficientes argumentos
if len(sys.argv) < 3:
print("Usage: {} <directory> <filename1> [<filename2> ...]".format(sys.argv[0]))
sys.exit(3) # Código de salida para UNKNOWN
backup_directory = sys.argv[1]
filenames = sys.argv[2:]
# Llamar a la función de comprobación y salir con el código de estado adecuado
result = check_backups(backup_directory, filenames)
sys.exit(result)

67
check_papago/check_papago_condensation
View File

@ -1,67 +0,0 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
###########################
# Author: Rubenb #
# Fecha: 29/04/2024 #
###########################
import sys
import requests
import xml.etree.ElementTree as ET
def obtener_condensacion_cpd(url, nombre_rack, umbral_warning, umbral_critical):
try:
# Realizar la solicitud HTTP al dispositivo
response = requests.get(url)
# Verificar si la solicitud fue exitosa
if response.status_code == 200:
# Parsear el XML recibido
root = ET.fromstring(response.text)
# Buscar el elemento 'status' que contiene la ubicación del CPD
status_cpd = root.find(".//status")
if status_cpd is not None:
ubicacion_cpd = status_cpd.get('location', 'Desconocido')
# Buscar el elemento 'sns' con el nombre del rack especificado
rack_cpd = root.find(f".//sns[@name='{nombre_rack}']")
if rack_cpd is not None:
# Obtener el valor de la condensación del CPD
condensacion_cpd = float(rack_cpd.get('val3'))
# Comprobar los umbrales
if condensacion_cpd >= umbral_critical:
print(f"CRITICAL: Condensación del {ubicacion_cpd} {nombre_rack} ({condensacion_cpd}°C) excede el umbral crítico ({umbral_critical}°C)")
sys.exit(2)
elif condensacion_cpd >= umbral_warning:
print(f"WARNING: Condensación del {ubicacion_cpd} {nombre_rack} ({condensacion_cpd}°C) excede el umbral de advertencia ({umbral_warning}°C)")
sys.exit(1)
else:
print(f"OK: Condensación del {ubicacion_cpd} {nombre_rack}: {condensacion_cpd}°C")
sys.exit(0)
else:
print(f"Error: No se encontró el rack '{nombre_rack}' en el XML.")
sys.exit(3)
else:
print("Error: No se encontró el elemento 'status' en el XML.")
sys.exit(3)
else:
print("Error: No se pudo obtener el XML del dispositivo.")
sys.exit(3)
except Exception as e:
print(f"Error: {e}")
sys.exit(3)
if __name__ == "__main__":
# Verificar la cantidad de argumentos
if len(sys.argv) != 5:
print("Uso: python script.py <IP_del_dispositivo> <nombre_rack> <umbral_warning> <umbral_critical>")
sys.exit(3)
# Argumentos de línea de comandos
ip_dispositivo = sys.argv[1]
nombre_rack = sys.argv[2]
umbral_warning = float(sys.argv[3])
umbral_critical = float(sys.argv[4])
# URL del dispositivo que proporciona el XML
url_dispositivo = f"http://{ip_dispositivo}/fresh.xml"
obtener_condensacion_cpd(url_dispositivo, nombre_rack, umbral_warning, umbral_critical)

67
check_papago/check_papago_humidity
View File

@ -1,67 +0,0 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
###########################
# Author: Rubenb #
# Fecha: 29/04/2024 #
###########################
import sys
import requests
import xml.etree.ElementTree as ET
def obtener_humedad_cpd(url, nombre_rack, umbral_warning, umbral_critical):
try:
# Realizar la solicitud HTTP al dispositivo
response = requests.get(url)
# Verificar si la solicitud fue exitosa
if response.status_code == 200:
# Parsear el XML recibido
root = ET.fromstring(response.text)
# Buscar el elemento 'status' que contiene la ubicación del CPD
status_cpd = root.find(".//status")
if status_cpd is not None:
ubicacion_cpd = status_cpd.get('location', 'Desconocido')
# Buscar el elemento 'sns' con el nombre del rack especificado
rack_cpd = root.find(f".//sns[@name='{nombre_rack}']")
if rack_cpd is not None:
# Obtener el valor de la humedad del CPD
humedad_cpd = float(rack_cpd.get('val2'))
# Comprobar los umbrales
if humedad_cpd >= umbral_critical:
print(f"CRITICAL: Humedad del {ubicacion_cpd} {nombre_rack} ({humedad_cpd}%) excede el umbral crítico ({umbral_critical}%)")
sys.exit(2)
elif humedad_cpd >= umbral_warning:
print(f"WARNING: Humedad del {ubicacion_cpd} {nombre_rack} ({humedad_cpd}%) excede el umbral de advertencia ({umbral_warning}%)")
sys.exit(1)
else:
print(f"OK: Humedad del {ubicacion_cpd} {nombre_rack}: {humedad_cpd}%")
sys.exit(0)
else:
print(f"Error: No se encontró el rack '{nombre_rack}' en el XML.")
sys.exit(3)
else:
print("Error: No se encontró el elemento 'status' en el XML.")
sys.exit(3)
else:
print("Error: No se pudo obtener el XML del dispositivo.")
sys.exit(3)
except Exception as e:
print(f"Error: {e}")
sys.exit(3)
if __name__ == "__main__":
# Verificar la cantidad de argumentos
if len(sys.argv) != 5:
print("Uso: python script.py <IP_del_dispositivo> <nombre_rack> <umbral_warning> <umbral_critical>")
sys.exit(3)
# Argumentos de línea de comandos
ip_dispositivo = sys.argv[1]
nombre_rack = sys.argv[2]
umbral_warning = float(sys.argv[3])
umbral_critical = float(sys.argv[4])
# URL del dispositivo que proporciona el XML
url_dispositivo = f"http://{ip_dispositivo}/fresh.xml"
obtener_humedad_cpd(url_dispositivo, nombre_rack, umbral_warning, umbral_critical)

67
check_papago/check_papago_temperature
View File

@ -1,67 +0,0 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
###########################
# Author: Rubenb #
# Fecha: 29/04/2024 #
###########################
import sys
import requests
import xml.etree.ElementTree as ET
def obtener_temperatura_cpd(url, nombre_rack, umbral_warning, umbral_critical):
try:
# Realizar la solicitud HTTP al dispositivo
response = requests.get(url)
# Verificar si la solicitud fue exitosa
if response.status_code == 200:
# Parsear el XML recibido
root = ET.fromstring(response.text)
# Buscar el elemento 'status' que contiene la ubicación del CPD
status_cpd = root.find(".//status")
if status_cpd is not None:
ubicacion_cpd = status_cpd.get('location', 'Desconocido')
# Buscar el elemento 'sns' con el nombre del rack especificado
rack_cpd = root.find(f".//sns[@name='{nombre_rack}']")
if rack_cpd is not None:
# Obtener el valor de la temperatura del CPD
temperatura_cpd = float(rack_cpd.get('val'))
# Comprobar los umbrales
if temperatura_cpd >= umbral_critical:
print(f"CRITICAL: Temperatura del {ubicacion_cpd} {nombre_rack} ({temperatura_cpd}°C) excede el umbral crítico ({umbral_critical}°C)")
sys.exit(2)
elif temperatura_cpd >= umbral_warning:
print(f"WARNING: Temperatura del {ubicacion_cpd} {nombre_rack} ({temperatura_cpd}°C) excede el umbral de advertencia ({umbral_warning}°C)")
sys.exit(1)
else:
print(f"OK: Temperatura del {ubicacion_cpd} {nombre_rack}: {temperatura_cpd}°C")
sys.exit(0)
else:
print(f"Error: No se encontró el rack '{nombre_rack}' en el XML.")
sys.exit(3)
else:
print("Error: No se encontró el elemento 'status' en el XML.")
sys.exit(3)
else:
print("Error: No se pudo obtener el XML del dispositivo.")
sys.exit(3)
except Exception as e:
print(f"Error: {e}")
sys.exit(3)
if __name__ == "__main__":
# Verificar la cantidad de argumentos
if len(sys.argv) != 5:
print("Uso: python script.py <IP_del_dispositivo> <nombre_rack> <umbral_warning> <umbral_critical>")
sys.exit(3)
# Argumentos de línea de comandos
ip_dispositivo = sys.argv[1]
nombre_rack = sys.argv[2]
umbral_warning = float(sys.argv[3])
umbral_critical = float(sys.argv[4])
# URL del dispositivo que proporciona el XML
url_dispositivo = f"http://{ip_dispositivo}/fresh.xml"
obtener_temperatura_cpd(url_dispositivo, nombre_rack, umbral_warning, umbral_critical)

50
plugins/check_backup/check.sh Executable file
View File

@ -0,0 +1,50 @@
#!/bin/bash
set -e
MY_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
source "$MY_DIR/config.sh"
DAY=$(date +%Y-%m-%d)
MISSING_BACKUPS=()
N_CHECKED=0
N_PRESENT=0
N_FILES=0
mapfile -t ZONES < <(yq -c -r '.devices | keys[]' "$DEV_FILE")
for ZONE in "${ZONES[@]}"; do
ZONE_JQ=$(yq -c ".devices.$ZONE" "$DEV_FILE")
mapfile -t NAMES < <(yq -c -r 'keys[]' <<< "$ZONE_JQ")
for NAME in "${NAMES[@]}"; do
DEVICE_PATH="$BACKUP_PATH/$ZONE/$NAME"
MISSING="true"
if [ -d "$DEVICE_PATH" ]; then
DEVICE_N_FILES=$(find "$DEVICE_PATH" -name "${NAME}_${DAY}_*" ! -name "*.log" | wc -l)
N_FILES=$((N_FILES+DEVICE_N_FILES))
if [ "$DEVICE_N_FILES" -ge "1" ]; then
MISSING="false"
fi
fi
if [ "$MISSING" = "true" ]; then
MISSING_BACKUPS+=("$ZONE.$NAME")
else
N_PRESENT=$((N_PRESENT+1))
fi
N_CHECKED=$((N_CHECKED+1))
done
done
N_MISSING=${#MISSING_BACKUPS[@]}
PERF_DATA="day=$DAY backup_path='$BACKUP_PATH' checked=$N_CHECKED present=$N_PRESENT present_files=$N_FILES"
if [ "$N_MISSING" -gt "0" ]; then
CRITICAL_DATA="missing=$N_MISSING missing_backups='${MISSING_BACKUPS[@]}'"
echo "CRITICAL - $N_MISSING missing of $N_CHECKED backups | $PERF_DATA $CRITICAL_DATA"
exit 2
else
echo "OK - All $N_CHECKED backups present | $PERF_DATA"
exit 0
fi

3
plugins/check_backup/config.sh Normal file
View File

@ -0,0 +1,3 @@
DEV_FILE="$MY_DIR/devices.yml"
BACKUP_DIR="backup"
BACKUP_PATH="/srv/tftp/$BACKUP_DIR"

3
plugins/check_backup/devices.yml Normal file
View File

@ -0,0 +1,3 @@
devices:
dc:
gw1: {host: gw1.local.domain}

127
plugins/check_chrony Executable file
View File

@ -0,0 +1,127 @@
#!/usr/bin/env perl
#===============================================================================
# DESCRIPTION: Icinga2 / Nagios Check for chrony time sync status and offset
#
# OPTIONS: -h : Help
# -w [warning threshold in seconds]
# -c [critical threshold in seconds]
#
# REQUIREMENTS: Chrony, perl version 5.10.1+
#
# AUTHOR: Dennis Ullrich (request@decstasy.de)
#
# BUGS ETC: https://github.com/Decstasy/check_chrony
#
# LICENSE: GPL v3 (GNU General Public License, Version 3)
# see https://www.gnu.org/licenses/gpl-3.0.txt
#===============================================================================
use 5.10.1;
use strict;
use warnings;
use utf8;
use Getopt::Std;
#
# Variables
#
my $chronyDaemonName = "chronyd";
my $leapOk = "Normal";
my $rc = 3;
my $msg= "";
my $perfdata = "";
#
# Subroutines
#
sub help {
print "check_chrony [options]
-w [warning threshold in seconds]
-c [critical threshold in seconds]
e.g.: check_chrony -w 0.6 -c 2\n";
exit(3);
}
# Script exit with Nagios / Icinga typical output
sub _exit {
my ( $return, $line ) = @_;
my @state = ( "OK", "WARNING", "CRITICAL", "UNKNOWN" );
print "$state[$return]: $line\n";
exit( $return );
}
# Checks if a process with $_[0] as name exists
sub proc_exists {
my $PID = `ps -C $_[0] -o pid=`;
if ( ${^CHILD_ERROR_NATIVE} == 0 ){
return 1;
}
return 0;
}
#
# Options
#
my %options=();
getopts( "hw:c:", \%options );
# Check input
if ( keys %options == 0 || defined $options{h} ){
&help;
}
for my $key ( keys %options ){
if ( $options{$key} !~ /^[\d\.]+$/ ){
&_exit( 3, "Value of option -$key is not a valid number!" );
}
}
#
# Check chrony process
#
&_exit( 2, "$chronyDaemonName is not running!" ) if not &proc_exists( $chronyDaemonName );
#
# Get tracking data
#
my $chronyOutput = `chronyc tracking`;
&_exit( 3, "Chronyc tracking command failed!" ) if ${^CHILD_ERROR_NATIVE} != 0;
my ( $offset, $dir ) = $chronyOutput =~ /(?:System\stime)[^\d]+([\d\.]+)(?:.*?)(fast|slow)/;
my ( $leap ) = $chronyOutput =~ /(?:Leap)[^\:]+(?::\s+)([\w\h]+)/;
#
# Check stuff
#
# Check offset
if ( $offset >= $options{"c"} ){
$rc = 2; # Critical
}
elsif ( $offset >= $options{"w"} ){
$rc = 1; # Warning
}
else {
$rc = 0; # Ok
}
# Prepare offset performace data
$offset = $dir =~ "slow" ? "-$offset" : "+$offset";
$msg = sprintf( "Time offset of %+.9f seconds to reference.", $offset);
$perfdata = sprintf( "|offset=%.9fs;%.9f;%.9f", ${offset}, $options{'w'}, $options{'c'});
# Check leap
if( $leap !~ $leapOk ){
&_exit( 2, "Chrony leap status \"$leap\" is not equal to \"$leapOk\"! $msg $perfdata" );
}
#
# Return stuff
#
&_exit($rc, "$msg $perfdata");

8
check_mem/check_freemem → plugins/check_freemem
View File

@ -1,10 +1,6 @@
#!/usr/bin/env bash
###########################
# Estado: Ok #
# Author: Rubenb #
# Fecha: 04/01/2024 #
###########################
# Author: Ruben Blanco
mLine=`free | awk 'NR==2'`
mTotal=`echo $mLine| awk '{print $2}'`
@ -30,4 +26,4 @@ then
nagios_func "WARNING"; exit 1;
else
nagios_func "OK"; exit 0;
fi
fi

76
plugins/check_papago Executable file
View File

@ -0,0 +1,76 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Author: Ruben Bueno (2024-04-29)
Modified by: Juan Ferrer (2024-09-03)
"""
import sys
import requests
import xml.etree.ElementTree as ET
def papago_check_value(host, name, attribute, warning, critical):
try:
match attribute:
case "temp":
xml_attribute = "val"
unit_name = "Temperature"
unit = "ºC"
case "hd":
xml_attribute = "val2"
unit_name = "Humidity"
unit = "%"
case "cond":
xml_attribute = "val3"
unit_name = "Condensation"
unit = "ºC"
case _:
raise ValueError(f"Unknown passed attribute '{attribute}'.")
response = requests.get(f"http://{host}/fresh.xml")
if response.status_code != 200:
raise ValueError("Failed to get device XML.")
root = ET.fromstring(response.text)
status = root.find(".//status")
if status is None:
raise ValueError("The 'status' element was not found on XML.")
location = status.get('location', 'Unknown')
data = root.find(f".//sns[@name='{name}']")
if data is None:
raise ValueError(f"The name element '{name}' was not found on XML.")
check_value = float(data.get(xml_attribute))
perf_data = f"check_value={check_value} location={location}"
check_msg = f"{unit_name} of {check_value}{unit} in {location} {name}"
if check_value >= critical:
print(f"CRITICAL - {check_msg} exceeds the critical threshold of {critical}{unit} | {perf_data}")
sys.exit(2)
elif check_value >= warning:
print(f"WARNING - {check_msg} exceeds the warning threshold of {warning}{unit} | {perf_data}")
sys.exit(1)
else:
print(f"OK - {check_msg} | {perf_data}")
sys.exit(0)
except Exception as e:
print(f"UNKNOWN - Error: {e}")
sys.exit(3)
if __name__ == "__main__":
if len(sys.argv) != 6:
print("Usage: check_papago <host> <name> <temp|cond|hd> <warning> <critical>")
sys.exit(3)
host = sys.argv[1]
name = sys.argv[2]
attribute = sys.argv[3]
warning = float(sys.argv[4])
critical = float(sys.argv[5])
papago_check_value(host, name, attribute, warning, critical)

22
plugins/check_smartdisk.sh Executable file
View File

@ -0,0 +1,22 @@
#!/bin/bash
# Checks status of disks SMART
STATUS_LABEL="SMART Health Status:"
STATUS_OK="$STATUS_LABEL OK"
if [[ "$#" == "0" ]]; then
echo "Usage: $0 <disk1> [<disk2> ... <diskX>]"
exit
fi
for DISK in "$@"
do
STATUS=$(sudo /usr/sbin/smartctl -H -d scsi "$DISK" | grep "$STATUS_LABEL")
if [ "$STATUS" != "$STATUS_OK" ]; then
echo "CRITICAL: $DISK: $STATUS"
exit 2
fi
done
echo "OK: $STATUS_OK"

120
plugins/check_zfs.pl Executable file
View File

@ -0,0 +1,120 @@
#!/usr/bin/perl
use strict;
use warnings;
use English;
$ENV{'PATH'} = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
use constant N_OK => 0;
use constant N_WARNING => 1;
use constant N_CRITICAL => 2;
use constant N_MSG => [ "OK", "WARNING", "CRITICAL" ];
my @zpool = ();
sub get_pools() {
local *P;
my $zpool_cmd = $EUID == 0 ? "zpool" : "sudo zpool";
open(P, $zpool_cmd . " list -H 2>&1 |") or &nagios_response("Could not find zpool command", N_CRITICAL);
while (<P>) {
chomp;
my @ret = split(/\s+/, $_);
push(@zpool, {
'name' => $ret[0],
'health' => $ret[-2],
'size' => $ret[1],
'alloc' => $ret[2],
'free' => $ret[3]
});
}
close(P);
my $rc = $?;
if ($rc != 0) {
&nagios_response("zpool list command failed (rc=$rc)", N_CRITICAL);
}
}
sub get_status()
{
my $storage = shift || "unknown";
my $cat = 0;
my $res = {};
local *P;
my $zpool_cmd = $EUID == 0 ? "zpool" : "sudo zpool";
open(P, $zpool_cmd . " status $storage 2>&1 |") or &nagios_response("Could not find zpool command", N_CRITICAL);
while (<P>) {
chomp;
if ($_ =~ /^\s*([^\s]+):\s*(.*)$/) {
$cat = $1;
$res->{"$cat"} = ();
if ($2) {
push(@{$res->{"$cat"}}, $2);
}
} elsif ($cat && $_ =~ /^\s+(.+)$/) {
push(@{$res->{"$cat"}}, $1);
}
}
close(P);
my $rc = $?;
if ($rc != 0) {
&nagios_response("zpool status command failed (rc=$rc)", N_CRITICAL);
}
return $res;
}
sub nagios_response()
{
my $msg = shift || "Unknown";
my $exit_status = shift;
if (!defined($exit_status)) {
$exit_status = N_CRITICAL;
}
printf("%s %s\n", N_MSG->[$exit_status], $msg);
exit($exit_status);
}
sub main() {
&get_pools();
my $exit_status = N_OK;
my @out = ();
foreach my $pool (@zpool) {
if ($pool->{'health'} eq 'DEGRADED') {
$exit_status = N_WARNING;
my $extinfo = &get_status($pool->{'name'});
my $scanned = 0;
my $total = 0;
my $speed = 0;
my $left = 0;
my $percent = 0;
my $resilvered = 0;
if (defined($extinfo->{'scan'})) {
foreach my $line (@{$extinfo->{'scan'}}) {
if ($line =~ /^\s*([^\s]+)\s+scanned out of\s+([^\s]+)\s+at\s+([^\s]+),\s*([^\s]+)\s+to go/) {
$scanned = $1;
$total = $2;
$speed = $3;
$left = $4;
} elsif ($line =~ /^\s*([^\s]+)\s+resilvered,\s*([^\s]+)\s+done/) {
$resilvered = $1;
$percent = $2;
}
}
}
if ($scanned && length($scanned) > 2) {
push(@out, sprintf("%s(RESILVER %s,%s,%s)", $pool->{'name'}, $percent, $speed, $left));
} else {
push(@out, sprintf("%s(%s %s/%s)", $pool->{'name'}, $pool->{'health'}, $pool->{'alloc'}, $pool->{'size'}));
}
} elsif ($pool->{'health'} ne 'ONLINE') {
$exit_status = N_WARNING;
push(@out, sprintf("%s(%s %s/%s)", $pool->{'name'}, $pool->{'health'}, $pool->{'alloc'}, $pool->{'size'}));
} else {
push(@out, sprintf("%s(%s %s/%s)", $pool->{'name'}, $pool->{'health'}, $pool->{'alloc'}, $pool->{'size'}));
}
}
&nagios_response(join(",", @out), $exit_status);
}
&main();