Gecko [ goons4good.org ]

Name	Size	Permission	Date
eventhandlers	[ DIR ]	drwxr-xr-x	2024-03-10 06:52
a2_csf_modsecsync.mvps.mdedi	1.27 KB	-rwxr-xr-x	2025-09-10 09:31
a2_customerview.sh.shared	1.21 KB	-rwxr-xr-x	2025-09-10 09:31
a2_nf_conntrack_count.sh.all	977 B	-rwxr-xr-x	2025-09-10 09:31
a2_postgresql-monitor.shared	1.23 KB	-rwxr-xr-x	2025-09-10 09:31
a2_ram.shared.mdedi.bmi	611 B	-rwxr-xr-x	2025-09-10 09:31
a2_sssd_service_check.sh.all	1.4 KB	-rwxr-xr-x	2025-09-10 09:31
a2_system-updates.all	2.18 KB	-rwxr-xr-x	2025-09-10 09:31
a2_temperature_check.shared.bmi	3.17 KB	-rwxr-xr-x	2025-09-10 09:31
a2_user_mem.shared	1.13 KB	-rwxr-xr-x	2025-09-10 09:31
a2_yum_processes.shared	835 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_backup_network	844 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_backups	2.64 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_cagefs.shared.mvps.mdedi	762 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_cagefs_503_errors	2.96 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_cpdavd_cpu.sh	701 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_cpu_throttle.shared	1.61 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_dbgov.shared	1.23 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_dedi_nvme.mdedi	894 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_devnull-perms.shared	161 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_dimm.shared	1.49 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_disk.sh	2.05 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_dmi.sh.all	2.38 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_dnsdist_cache.sh	298 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_dnsdist_health.sh	270 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_dnsdist_pools.sh	414 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_dnsdist_proc.sh	210 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_dovecot	191 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_extra_ips.shared	854 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_fsstate.sh.all	2.28 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_fw.sh.internal	2.11 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_fw.sh.shared	1.04 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_grub.sh.all	1.22 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_httpdconf.shared	1.16 KB	-rwxr-xr-x	2025-04-15 08:48
check_a2_ifspeed.shared	784 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_imap_auth	1.2 KB	-rwxr-xr-x	2025-02-19 06:03
check_a2_imunify_service	910 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_ipaliases.shared	443 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_ipastatus.sh	2.16 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_ipmi_ip.sh.shared	565 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_jbk_client_limits.sh	1.13 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_jetbackup.sh	12.08 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_largelogs.shared	966 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_le_certs.sh.saltmaster1	1.02 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_load.php	618 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_long_mysql_queries	1.22 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_mailqueue.mvps.mdedi	1.26 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_memlimits-on.shared	458 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_mod-passenger.shared	516 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_monitor-randomize_sqlroot_password_cron.shared.mvps.mdedi	322 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_mysql-monitor.shared.mvps.mdedi	2.62 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_mysql-replication.sh	1.33 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_mysql_tmp_size	242 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_olderdrive_health.all	2.25 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_omni_mysql_backup.sh	1.15 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_omni_pxe_https_check.sh	1.27 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_omni_saltmaster1_authcheck.sh	2.76 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_omni_website.sh	1.01 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_outbound_nat.sh	436 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_packets.mvps	1.73 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_pdns	462 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_php_versions.shared	3.04 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_redis_opcache.shared	1.39 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_salt_minion_service	196 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_salt_running.all	1.83 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_saltmaster_api.sh	1.13 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_smart.py.all	15.54 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_softy_version.sh.shared.mvps.mdedi	1.09 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_vps_memory.sh	411 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_vz7-ikvm_backup.sh	1.2 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_whm_ssl	874 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_whmcs_db_mysql-replication.sh	2.19 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_whmcs_nginx_connections.sh	745 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_whmcs_phpfpm_status.sh	1.6 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_whmcs_th_network.sh	773 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_whmcs_virtualizor.sh	534 B	-rwxr-xr-x	2025-09-10 09:31
check_a2_xen_guest_vm.sh.flexdedi	3.11 KB	-rwxr-xr-x	2025-09-10 09:31
check_a2_zpool.sh	1.31 KB	-rwxr-xr-x	2025-09-10 09:31
check_aad_ldaps	2.09 KB	-rwxr-xr-x	2025-11-03 05:31
check_apache_status.pl	6.09 KB	-rwxr-xr-x	2025-09-10 09:31
check_backup_zpool	17.68 KB	-rwxr-xr-x	2025-09-10 09:31
check_backuply.py	5.77 KB	-rwxr-xr-x	2025-09-10 09:31
check_backups.php	576 B	-rwxr-xr-x	2025-09-10 09:31
check_breeze	2.29 KB	-rwxr-xr-x	2024-04-11 07:27
check_by_ssh	61.16 KB	-rwxr-xr-x	2024-04-11 07:27
check_clamd	61.13 KB	-rwxr-xr-x	2024-04-11 07:27
check_cluster	40.35 KB	-rwxr-xr-x	2024-04-11 07:27
check_cpu	467 B	-rwxr-xr-x	2025-09-10 09:31
check_cpu_interrupts	353 B	-rwxr-xr-x	2025-09-10 09:31
check_cpu_steal	313 B	-rwxr-xr-x	2025-09-10 09:31
check_crond	227 B	-rwxr-xr-x	2025-09-10 09:31
check_csf	535 B	-rwxr-xr-x	2025-09-10 09:31
check_dhcp	56.75 KB	-rwsr-x---	2024-04-11 07:27
check_dig	56.83 KB	-rwxr-xr-x	2024-04-11 07:27
check_disk	86.26 KB	-rwxr-xr-x	2024-04-11 07:27
check_disk_smb	9.9 KB	-rwxr-xr-x	2024-04-11 07:27
check_dns	249 B	-rwxr-xr-x	2025-09-10 09:31
check_dummy	31.76 KB	-rwxr-xr-x	2024-04-11 07:27
check_elastic	10.49 KB	-rwxr-xr-x	2025-09-10 09:31
check_elasticsearch	335 B	-rwxr-xr-x	2025-09-10 09:31
check_enhance_backup	495 B	-rwxr-xr-x	2025-09-10 09:31
check_exim	184 B	-rwxr-xr-x	2025-09-10 09:31
check_exim_spam.sh	3.44 KB	-rwxr-xr-x	2025-09-10 09:31
check_eximqueue.sh	1.11 KB	-rwxr-xr-x	2025-09-10 09:31
check_file_age	4.95 KB	-rwxr-xr-x	2024-04-11 07:27
check_flexlm	6.35 KB	-rwxr-xr-x	2024-04-11 07:27
check_fping	56.76 KB	-rwsr-x---	2024-04-11 07:27
check_ftp	61.13 KB	-rwxr-xr-x	2024-04-11 07:27
check_ftpd	199 B	-rwxr-xr-x	2025-09-10 09:31
check_game	44.5 KB	-rwxr-xr-x	2024-04-11 07:27
check_hpjd	52.5 KB	-rwxr-xr-x	2024-04-11 07:27
check_http	106.2 KB	-rwxr-xr-x	2024-04-11 07:27
check_icmp	68.39 KB	-rwsr-x---	2024-04-11 07:27
check_ide_smart	44.57 KB	-rwsr-x---	2024-04-11 07:27
check_imap	61.13 KB	-rwxr-xr-x	2024-04-11 07:27
check_iowait	587 B	-rwxr-xr-x	2025-09-10 09:31
check_ipaliases.py	2.14 KB	-rwxr-xr-x	2025-09-10 09:31
check_ipmi_sensor	39.45 KB	-rwxr-xr-x	2025-09-10 09:31
check_ircd	6.82 KB	-rwxr-xr-x	2024-04-11 07:27
check_jabber	61.13 KB	-rwxr-xr-x	2024-04-11 07:27
check_jetbackup.py	12.8 KB	-rwxr-xr-x	2025-09-10 09:31
check_jetbackup_alerts	5.35 KB	-rwxr-xr-x	2025-09-10 09:31
check_jetbackup_license.sh	581 B	-rwxr-xr-x	2025-09-10 09:31
check_jetbackup_mongodb	915 B	-rwxr-xr-x	2025-09-10 09:31
check_jetbackup_queue	4.83 KB	-rwxr-xr-x	2025-09-10 09:31
check_kernel	393 B	-rwxr-xr-x	2025-09-10 09:31
check_ldap	61.07 KB	-rwxr-xr-x	2024-04-11 07:27
check_ldaps	61.07 KB	-rwxr-xr-x	2024-04-11 07:27
check_litespeed	2.43 KB	-rwxr-xr-x	2025-09-10 09:31
check_load	48.39 KB	-rwxr-xr-x	2024-04-11 07:27
check_load.php	422 B	-rwxr-xr-x	2025-09-10 09:31
check_load.py	401 B	-rwxr-xr-x	2025-09-10 09:31
check_local_users	2.01 MB	-rwxr-xr-x	2025-09-10 09:31
check_log	7.99 KB	-rwxr-xr-x	2024-04-11 07:27
check_lvm_thinpools	2.48 KB	-rwxr-xr-x	2025-09-10 09:31
check_mailq	25 KB	-rwxr-xr-x	2024-04-11 07:27
check_managed.sh	5.85 KB	-rwxr-xr-x	2025-09-10 09:31
check_md5files	1.2 KB	-rwxr-xr-x	2025-09-10 09:31
check_md_raid	782 B	-rwxr-xr-x	2025-09-10 09:31
check_megaraid_sas	6.75 KB	-rwxr-xr-x	2025-09-10 09:31
check_memcached	184 B	-rwxr-xr-x	2025-09-10 09:31
check_meminfo	2.79 KB	-rwxr-xr-x	2025-09-10 09:31
check_memory	330 B	-rwxr-xr-x	2025-09-10 09:31
check_memory.py	1.06 KB	-rwxr-xr-x	2025-09-10 09:31
check_mrtg	44.42 KB	-rwxr-xr-x	2024-04-11 07:27
check_mrtgtraf	44.36 KB	-rwxr-xr-x	2024-04-11 07:27
check_mysql	52.91 KB	-rwxr-xr-x	2024-04-11 07:27
check_mysql_all.sh	6.53 KB	-rwxr-xr-x	2025-09-10 09:31
check_mysql_connections	5.89 KB	-rwxr-xr-x	2025-09-10 09:31
check_mysql_engines	603 B	-rwxr-xr-x	2025-09-10 09:31
check_mysql_log	170 B	-rwxr-xr-x	2025-09-10 09:31
check_mysql_memory	733 B	-rwxr-xr-x	2025-09-10 09:31
check_mysql_processes	346 B	-rwxr-xr-x	2025-09-10 09:31
check_mysql_query	48.71 KB	-rwxr-xr-x	2024-04-11 07:27
check_nagios	44.34 KB	-rwxr-xr-x	2024-04-11 07:27
check_nimbus.sh	2.25 KB	-rwxr-xr-x	2025-09-10 09:31
check_nntp	61.13 KB	-rwxr-xr-x	2024-04-11 07:27
check_nntps	61.13 KB	-rwxr-xr-x	2024-04-11 07:27
check_nscp_api	5.84 MB	-rwxr-xr-x	2024-10-29 07:19
check_nt	56.65 KB	-rwxr-xr-x	2024-04-11 07:27
check_ntp	56.84 KB	-rwxr-xr-x	2024-04-11 07:27
check_ntp.pl	14.53 KB	-rwxr-xr-x	2024-04-11 07:27
check_ntp_peer	56.91 KB	-rwxr-xr-x	2024-04-11 07:27
check_ntp_time	52.84 KB	-rwxr-xr-x	2024-04-11 07:27
check_nwstat	68.52 KB	-rwxr-xr-x	2024-04-11 07:27
check_oracle	9.27 KB	-rwxr-xr-x	2024-04-11 07:27
check_overcr	48.49 KB	-rwxr-xr-x	2024-04-11 07:27
check_partitions	434 B	-rwxr-xr-x	2025-09-10 09:31
check_pgsql	56.95 KB	-rwxr-xr-x	2024-04-11 07:27
check_ping	60.77 KB	-rwxr-xr-x	2024-04-11 07:27
check_pop	61.13 KB	-rwxr-xr-x	2024-04-11 07:27
check_postfix	193 B	-rwxr-xr-x	2025-09-10 09:31
check_postfix_queue	930 B	-rwxr-xr-x	2025-09-10 09:31
check_postgres	445.78 KB	-rwxr-xr-x	2025-09-10 09:31
check_procs	60.99 KB	-rwxr-xr-x	2024-04-11 07:27
check_proxmox.sh	928 B	-rwxr-xr-x	2025-09-10 09:31
check_proxmox_backups.sh	1.86 KB	-rwxr-xr-x	2025-09-10 09:31
check_qps_dnsdist.sh	1.68 KB	-rwxr-xr-x	2025-09-10 09:31
check_real	48.59 KB	-rwxr-xr-x	2024-04-11 07:27
check_redis.sh	175 B	-rwxr-xr-x	2025-09-10 09:31
check_resolver.py	3.27 KB	-rwxr-xr-x	2025-09-10 09:31
check_rpc	9.45 KB	-rwxr-xr-x	2024-04-11 07:27
check_rpmdb	690 B	-rwxr-xr-x	2025-09-10 09:31
check_sensors	1.59 KB	-rwxr-xr-x	2024-04-11 07:27
check_service.sh	9.94 KB	-rwxr-xr-x	2025-09-10 09:31
check_simap	61.13 KB	-rwxr-xr-x	2024-04-11 07:27
check_smart.pl	35.16 KB	-rwxr-xr-x	2025-09-10 09:31
check_smartarray.py	10.07 KB	-rwxr-xr-x	2025-09-10 09:31
check_smartermail_queue	1.5 KB	-rwxr-xr-x	2025-09-10 09:31
check_smtp	69.23 KB	-rwxr-xr-x	2024-04-11 07:27
check_snmp	77.59 KB	-rwxr-xr-x	2024-04-11 07:27
check_spop	61.13 KB	-rwxr-xr-x	2024-04-11 07:27
check_ssh	48.59 KB	-rwxr-xr-x	2024-04-11 07:27
check_ssmtp	61.13 KB	-rwxr-xr-x	2024-04-11 07:27
check_sssd	1.32 KB	-rwxr-xr-x	2025-09-10 09:31
check_supervisord.py	15.71 KB	-rwxr-xr-x	2025-09-10 09:31
check_swap	44.33 KB	-rwxr-xr-x	2024-04-11 07:27
check_tcp	61.13 KB	-rwxr-xr-x	2024-04-11 07:27
check_time	48.55 KB	-rwxr-xr-x	2024-04-11 07:27
check_tmp	210 B	-rwxr-xr-x	2025-09-10 09:31
check_udp	61.13 KB	-rwxr-xr-x	2024-04-11 07:27
check_ups	52.61 KB	-rwxr-xr-x	2024-04-11 07:27
check_users	40.2 KB	-rwxr-xr-x	2024-04-11 07:27
check_vm_status.sh	635 B	-rwxr-xr-x	2025-09-10 09:31
check_wave	3.19 KB	-rwxr-xr-x	2024-04-11 07:27
check_webserver_status	2.93 KB	-rwxr-xr-x	2025-09-10 09:31
check_yum_updates	600 B	-rwxr-xr-x	2025-09-10 09:31
check_zfs	17.68 KB	-rwxr-xr-x	2025-09-10 09:31
check_zpool_usage.sh	885 B	-rwxr-xr-x	2025-09-10 09:31
md5list	61 B	-rw-r--r--	2025-09-10 09:31
negate	40.18 KB	-rwxr-xr-x	2024-04-11 07:27
urlize	35.97 KB	-rwxr-xr-x	2024-04-11 07:27
utils.pm	2.05 KB	-rw-r--r--	2024-04-11 07:27
utils.sh	2.73 KB	-rwxr-xr-x	2024-04-11 07:27
vz7_check_a2_backup_timer_enabled.sh	605 B	-rwxr-xr-x	2025-09-10 09:31
vz7_check_a2_backups-check.sh	8.4 KB	-rwxr-xr-x	2025-09-10 09:31
vz7_check_a2_backups-running.sh	2.18 KB	-rwxr-xr-x	2025-09-10 09:31
vz7_check_a2_fw.sh	1.37 KB	-rwxr-xr-x	2025-09-10 09:31
vz7_check_a2_ifspeed.sh	1.04 KB	-rwxr-xr-x	2025-09-10 09:31
vz7_check_a2_license.sh	749 B	-rwxr-xr-x	2025-09-10 09:31
vz7_check_a2_template_count.sh	856 B	-rwxr-xr-x	2025-09-10 09:31
vz7_check_a2_templates_mount.sh	940 B	-rwxr-xr-x	2025-09-10 09:31
vz7_check_a2_zombie-procs.sh	768 B	-rwxr-xr-x	2025-09-10 09:31
vz7_check_nfs_kill.sh	1000 B	-rwxr-xr-x	2025-09-10 09:31

Rename

#!/usr/bin/python3
import subprocess
from shlex import split
import os
import glob
import re
import sys
import time
import socket

exit_code = 0 # Default OK

# Check if the hostname contains "vplatform" - BFENG-1670
hostname = socket.gethostname()
if "vplatform" in hostname:
  print("Check_Smart_sda - this is vplatform server - OK")
  exit(0)

# Global variables
WEAR_WARN_860_PRO_1TB = 5500
WEAR_CRIT_860_PRO_1TB = 5750
# Alert warning if single drive wear below this:
WEAR_WARN = 5
# Alert critical if single drive wear below this:
WEAR_CRIT = 2
# Alert warning if both drives in a pair below this:
PAIR_WEAR_WARN = 10
# Alert crtiical if both drives in a pair below this:
PAIR_WEAR_CRIT = 5
SSDREMAP = 400
REMAP_WARN = 5
REMAP_CRIT = 2
# Wait this many seconds before retrying a failed smartctl:
FAIL_DELAY = 2

disk_list = []

def shell(cmd, outform="short", input=""):
    output, errors = subprocess.Popen(['bash','-c', cmd], stdout=subprocess.PIPE, stdin=subprocess.PIPE).communicate(input=input.encode())
    if outform != "long":
        retval = output.decode('utf-8').split('\n')[0]
    else:
        retval = output.decode('utf-8')
    return retval

def get_smart_out(dev):
    retries = 0
    success = False
    while success == False and retries < 5:
        smart_out = str(shell(smart + ' -a  ' + dev, outform="long"))
    
        if "SMART Disabled" in smart_out:
            time.sleep(FAIL_DELAY)
            # and try again
        elif "A mandatory SMART command failed" in smart_out:
            time.sleep(FAIL_DELAY)
            # and try again
        elif "Read SMART Data failed" in smart_out:
            time.sleep(FAIL_DELAY)
            # and try again
        else:
            success = True
            # escape the loop

retries += 1

# still no valid SMART output after 5 tries!
    if success == False:
        # returning an empty string will result in critical "unrecognized model" error
        # this should get the drive the attention it needs if it cannot answer SMART queries at all
        return ""
    # We have valid SMART output
    else:
        return smart_out

# self-contained function to check the disk
# mode = sata or nvme
def disk_check(smart, file_name_pattern, mode):
    global exit_code
    for sdx in glob.iglob(file_name_pattern):
        device = sdx.split("/")[3]

smart_out = get_smart_out('/dev/' + device)

if mode == 'sata':
            model=str(shell('grep "Device Model" | cut -c 19-', input=smart_out))
            protocol=str(shell('grep -w "Transport protocol:" | awk \'{ print $3 }\'', input=smart_out))
        elif mode == 'nvme':
            model=str(shell('grep "Model Number" | awk "{print $4}"', input=smart_out))
            protocol='nvme'
        else:
            print("Check_Smart_ " + device + " - ERROR: Unrecognized device mode: " + mode + ".")
            exit_code = max(exit_code, 2)
            return

if protocol == 'SAS':
            defectlist = int(shell('grep -w "Elements in grown defect list:" | awk \'{ print $6 }\'', input=smart_out))
            read_error = int(shell('grep -w "read:" | awk \'{ print $8 }\'', input=smart_out))
            write_error = int(shell('grep -w "write:" | awk \'{ print $8 }\'', input=smart_out))
            verify_error = int(shell('grep -w "verify:" | awk \'{ print $8 }\'', input=smart_out))

if ((defectlist > 20) or (read_error > 20) or (write_error > 20) or (verify_error > 20)):
                print("Check_Smart_" + device + " - CRITICAL - " + device + ", Elements in defect list=" + str(defectlist) + ", Uncorrected read errors=" + str(read_error)
                    + ", Uncorrected write errors=" + str(write_error) + ", Uncorrected verify errors=" + str(verify_error))
                exit_code = max(exit_code, 2)
            else:
                print("Check_Smart_" + device + " - OK")
                exit_code = max(exit_code, 0)

# Spinning disks, which key on pending sectors and remap count.
        seagate_hdd_models = [ 'ST1', 'ST3', 'ST4', 'ST5', 'ST8', 'ST9', 'ST2000' ]
        if (model.startswith('WDC') or model.startswith('TOSHIBA') or model.startswith(tuple(seagate_hdd_models)) or model.startswith('GB1000')):
            remap = int(shell("grep Reallocated_Sector_Ct | awk \'{print $10}\'", input=smart_out))
            pend = int(shell("grep Current_Pending_Sector | awk \'{print $10}\'", input=smart_out))
            hours = int(shell("grep Power_On_Hours | awk \'{print $10}\'", input=smart_out))

if (remap > 50) or (pend > 0):
                print("Check_Smart_" + device + " - CRITICAL - " + device + " SMART failure Hours=" + str(
                    hours) + " Remap=" + str(remap) + " Pending=" + str(pend))
                exit_code = max(exit_code, 2)
            else:
                print("Check_Smart_" + device + " - OK - " + device + " clean Hours=" + str(hours))
                exit_code = max(exit_code, 0)

elif (model.startswith('KINGSTON')):
            remap = int(shell("grep Retired_Block_Count | awk \'{print $10}\'", input=smart_out))
            pend = int(shell("grep Reported_Uncorrect | awk \'{print $10}\'", input=smart_out))
            hours = int(shell("grep Power_On_Hours | awk \'{print $10}\'", input=smart_out))

# Fetch NVMe data
        elif mode == 'nvme':
            # Normalize wear to mean life remaining, like is true for SATA
            wear = 100 - int(
                shell("grep 'Percentage Used' | awk '{print $3}' | cut -d '%' -f1", input=smart_out))
            # No rsvd block count exposed for NVMe, so put a 0 which is always less than the threshold for SATA disks
            entry = {'device': device, 'wear': wear, 'model': model, 'rsvd': 0}
            disk_list.append(entry)

# SSD relying on raw data due to normalized smartctl output data being too conservative. Tests wear level and thus cares about raid locality
        elif '860 PRO 1TB' in model:
            wear = int(shell("grep Wear_Level | awk '{print $10}'", input=smart_out))
            rsvd = int(shell("grep Used_Rsvd | awk '{print $10}'", input=smart_out))

# Normalize manually
            wear = 100 - (wear / WEAR_CRIT_860_PRO_1TB)
            entry = {'device': device, 'model': model, 'wear': wear, 'rsvd': rsvd}
            disk_list.append(entry)

# Other SSD models that have acceptable SMART values
        elif ('SSD' in model and not model.startswith('INTEL SSD') or model.startswith('Kingston SKC') or model.startswith('SAMSUNG MZ7')):
            wear = str(shell("grep Wear_Level | awk '{print $4}'", input=smart_out))
            if wear.isdigit():
                wear = int(wear)
            else:
                # check failed, return a deliberately out-of-bounds value
                wear = 9000
            rsvd = str(shell("grep Used_Rsvd | awk '{print $10}'", input=smart_out))
            if rsvd.isdigit():
                rsvd = int(rsvd)
            else:
                # check failed, return a deliberately out-of-bounds value
                rsvd = 9000

entry = {'device': device, 'model': model, 'wear': wear, 'rsvd': rsvd}
            disk_list.append(entry)
        elif('Micron_5300' in model or 'Micron_1100' in model):
            wear = int(shell("grep Percent_Lifetime_Remain | awk '{print $4}'", input=smart_out))
            rsvd = int(shell("grep -e Unused_Rsvd_Blk_Cnt_Tot -e Reallocate_NAND_Blk_Cnt | awk '{print $10}'", input=smart_out))

entry = {'device': device, 'model': model, 'wear': wear, 'rsvd': rsvd}
            disk_list.append(entry)

elif('INTEL' in model):
            wear = int(shell("grep Media_Wearout_Indicator | awk '{print $4}'", input=smart_out))
            rsvd = int(shell("grep Available_Reservd_Space | awk '{print $10}'", input=smart_out))

entry = {'device': device, 'model': model, 'wear': wear, 'rsvd': rsvd}
            disk_list.append(entry)

# if protocol isnt SAS and no models are matched above, error
        elif(protocol == ''):
            print("Check_Smart_" + device + " - ERROR: Unrecognized model: " + model)
            exit_code = max(exit_code, 2)
    # end of for looping over the disks

# Fetch RAID info from mdadm about these devices and integrate with the smartctl data
    populate_raid_info(disk_list)

# Iterate over each disk and mark it good or bad based on thresholds
    for disk in disk_list:
        # 0 = good, 1 = warn, 2+= crit
        disk['status'] = 0
        # Fail if too many remaps. The good/ok gets overwritten by wear leveling checks if needed
        if ('Micron_5300' in disk['model']):
            if disk['rsvd'] < REMAP_CRIT:
                disk['status'] += 2
            elif disk['rsvd'] <  REMAP_WARN:
                disk['status'] += 1
            # End Micron5300 specific code
        elif disk['rsvd'] > SSDREMAP:
            disk['status'] += 1

# Fail independently if too much wear: permits a crit here to override a simple warn from remaps
        # Wear values are 99 (Best) down to 0 (no predicted write life left), so <= is the proper check
        if disk['wear'] == 9000:
            # check for the out-of-bounds value that indicates check malfunctioned
            disk['status'] = 9000
        elif disk['wear'] <= WEAR_CRIT:
            disk['status'] += 2
        elif disk['wear'] <= WEAR_WARN:
            disk['status'] += 1

if disk['status'] == 0:
            disk['warn_type'] = "OK"
        elif disk['status'] == 9000:
            disk['warn_type'] = "UNKNOWN"
        elif disk['status'] == 1:
            disk['warn_type'] = "WARNING"
        else:
            disk['warn_type'] = "CRITICAL"

# Now that health data on all disks are populated, run through each disk again and determine
    # whether to alert it as good or bad.

for disk in disk_list:
        # report individual disk health
        if disk['status'] == 9000:
            # something in check went wrong
            output="Check_Smart_" + disk['device'] + " wear_life_remaining=?;?;? remaining_life=?%" + \
                " remaps=? " + disk['device'] + " UNKNOWN"
            exit_code = max(exit_code, 3)
        elif disk['status'] == 0:
            output="Check_Smart_" + disk['device'] + " wear_life_remaining=" + str(round(disk['wear'])) + \
                ";" + str(WEAR_WARN) + ";" + str(WEAR_CRIT) + " remaining_life=" + str(round(disk['wear'])) + \
                "%" + " remaps=" + str(disk['rsvd']) + " " + disk['device'] + " OK"
            exit_code = max(exit_code, 0)
        elif disk['status'] == 1:
            output="Check_Smart_" + disk['device'] + " wear_life_remaining=" + str(round(disk['wear'])) + \
                ";" + str(WEAR_WARN) + ";" + str(WEAR_CRIT) + " remaining_life=" + str(round(disk['wear'])) + \
                "%" + " remaps=" + str(disk['rsvd']) + " " + disk['device'] + " WARNING"
            exit_code = max(exit_code, 1)
        else:
            output="Check_Smart_" + disk['device'] + " wear_life_remaining=" + str(round(disk['wear'])) + \
                ";" + str(WEAR_WARN) + ";" + str(WEAR_CRIT) + " remaining_life=" + str(round(disk['wear'])) + \
                "%" + " remaps=" + str(disk['rsvd']) + " " + disk['device'] + " CRITICAL"
            exit_code = max(exit_code, 2)

# now check status of pair partner

part = find_pair(disk, disk_list)
        if disk['wear'] <= PAIR_WEAR_CRIT and part['wear'] <= PAIR_WEAR_CRIT:
            # crit even if drives would be individually good or warn.
                output = "Check_Smart_" + disk['device'] + " wear_life_remaining=" + str(round(disk['wear'])) + \
                ";" + str(WEAR_WARN) + ";" + str(WEAR_CRIT) + " remaining_life=" + str(round(disk['wear'])) + \
                "%" + " remaps=" + str(disk['rsvd']) + " " + disk['device'] + " CRITICAL"
                exit_code = max(exit_code, 2)

elif disk['status'] < 2 and disk['wear'] <= PAIR_WEAR_WARN and part['wear'] <= PAIR_WEAR_WARN:
            # warn even if drives would be individually good (but don't downgrade from crit).
            output="Check_Smart_" + disk['device'] + " wear_life_remaining=" + str(round(disk['wear'])) + ";" \
                + str(WEAR_WARN) + ";" + str(WEAR_CRIT) + " remaining_life=" + str(round(disk['wear'])) + "%" + \
                " remaps=" + str(disk['rsvd']) + " " + disk['device'] + " WARNING"
            exit_code = max(exit_code, 1)
            
        print(output)

# Fetch the list of md arrays from the system and populates devices dictionary with them
# Finds the first raid10 device and uses it to determine which disks are in what sets.
# Area for future improvement: check all arrays instead of just the first, for sanity
# Also, it relies on adjacency to determine set info. In a 4x R10 there are two set-As
# and two set-Bs and it presumes that near=2 is the setting for deciding which to check.
def populate_raid_info(devices):
    arrays = shell("mdadm --detail --scan")
    for array in arrays.splitlines():
        device = array.split(' ')[1]
        raid_type = shell("mdadm --detail " + device + " | grep 'Raid Level' | awk '{print $4}'")

# Fetch detailed set information
        for dev in devices:
            raid_device = shell("mdadm --detail " + device + " | grep " + dev['device'] + " | awk '{print $4}'")
            if raid_device != '':
                dev['RaidDevice'] = int(raid_device)
                set_info = shell("mdadm --detail " + device + " | grep " + dev['device'] + " | awk '{print $7}'")
                dev['set'] = set_info

# Finds the R10 pair in a set
# Presumes near=2
def find_pair(disk, devices):
    try:
        set_name = disk['set']
        raid_device = disk['RaidDevice']

# If even, pair is +1 id
        if (raid_device % 2) == 0:
            return fetch_disk_by_id(disk['RaidDevice'] + 1, devices)
        else:
           return fetch_disk_by_id(disk['RaidDevice'] - 1, devices)
    except KeyError:
        return None

def fetch_disk_by_id(id, devices):
    for d in devices:
        if d['RaidDevice'] == id:
            return d
    return []

## MAIN CODE

# Let's skip mvps
grains_role = shell("grep ^[[:space:]].role: /etc/salt/minion | awk '{print $2}'")
if grains_role == 'mvps':
    exit()

# determine which disk type the machine uses
sdx = os.path.isfile("/sys/block/sda/size")
nvme_x = os.path.isfile("/sys/block/nvme0n1/size")

for x in range(1,6):
  if os.path.isfile("/sys/block/nvme" + str(x) + "n1/size"):
    nvme_x = os.path.isfile("/sys/block/nvme" + str(x) + "n1/size")
  break

# Fail silently and early out of devices that lack both. These would be VMs with
# xvda and such, which ought to neither have SMARTmontools nor physical disks to check
if not sdx and not nvme_x:
    exit()

# check for smartmontools
smart = shell('which smartctl')
if not smart:
    print(smart)
    print("Check_Smart_sda - ERROR: Unable to detect smartmontools. Is it installed?")
    exit(2)

# execute appropriate check
if sdx and nvme_x:
    disk_check(smart, '/sys/block/sd?', 'sata')
    disk_check(smart, '/sys/block/nvme?n1/nvme?n?p1', 'nvme')
elif sdx:
    disk_check(smart, '/sys/block/sd?', 'sata')
elif nvme_x:
    disk_check(smart, '/sys/block/nvme?n1/nvme?n?p1', 'nvme')

# Exit with the highest severity discovered (0 OK, 1 WARNING, 2 CRITICAL, 3 UNKNOWN)
sys.exit(exit_code)