check_cpu_cisco

Check CPU Simple

#!/bin/bash

#Parse command-line arguments,
while getopts "H:up:A:X:w©" opt; do
  case $opt in
    H) HOST="$OPTARG" ;;
    u) USER="$OPTARG" ;;
    a) AUTH_PASS="$OPTARG" ;;
    p) PRIV_PASS="$OPTARG" ;;
    A) AUTH_PROTO="$OPTARG" ;;  # e.g., SHA or MD5
    X) PRIV_PROTO="$OPTARG" ;;  # e.g., AES or DES
    w) WARNING="$OPTARG" ;;
    c) CRITICAL="$OPTARG" ;;
    *)
      echo "Usage: $0 -H host -u user -a auth_pass -p priv_pass -A auth_proto -X priv_proto [-w warning] [-c critical]"
      exit 3
      ;;
  esac
done

# Check if WARNING or CRITICAL are still empty or hold a flag
[[ -z "$WARNING" || "$WARNING" == -* ]] && WARNING=70
[[ -z "$CRITICAL" || "$CRITICAL" == -* ]] && CRITICAL=90

#Validate required variables,
if [[ -z "$HOST"  -z "$USER"  -z "$AUTH_PASS"  -z "$PRIV_PASS"  -z "$AUTH_PROTO"  -z "$PRIV_PROTO" ]]; then
  echo "UNKNOWN - Missing required arguments"
  exit 3
fi

#Cisco 5-second CPU utilization OID,
CPU_OID="1.3.6.1.4.1.9.9.109.1.1.1.1.6.7"

#Get CPU usage,
CPU_USAGE=$(snmpget -v3 -u "$USER" -a "$AUTH_PROTO" -A "$AUTH_PASS" -x "$PRIV_PROTO" -X "$PRIV_PASS" -l authPriv "$HOST" "$CPU_OID" 2>/dev/null | awk '{print $NF}')

#Validate response,
if [[ -z "$CPU_USAGE"  ! "$CPU_USAGE" =~ ^[0-9]+$ ]]; then
  echo "UNKNOWN - Unable to retrieve CPU usage"
  exit 3
fi

#Determine Nagios status,
if (( CPU_USAGE >= CRITICAL )); then
  echo "CRITICAL - CPU usage is ${CPU_USAGE}% on $HOST"
  exit 2
elif (( CPU_USAGE >= WARNING )); then
  echo "WARNING - CPU usage is ${CPU_USAGE}% on $HOST"
  exit 1
else
  echo "OK - CPU usage is ${CPU_USAGE}% on $HOST"
  exit 0
fi

Check CPU

#!/bin/bash

# Parse command-line arguments,
while getopts "H:up:A:X:w©" opt; do
  case $opt in
    H) HOST="$OPTARG" ;;
    u) USER="$OPTARG" ;;
    a) AUTH_PASS="$OPTARG" ;;
    p) PRIV_PASS="$OPTARG" ;;
    A) AUTH_PROTO="$OPTARG" ;;
    X) PRIV_PROTO="$OPTARG" ;;
    w) WARNING="$OPTARG" ;;
    c) CRITICAL="$OPTARG" ;;
    )
      echo "Usage: $0 -H host -u user -a auth_pass -p priv_pass -A auth_proto -X priv_proto [-w warning] [-c critical]"
      exit 3
      ;;
  esac
done

# Set default thresholds,
[[ -z "$WARNING" || "$WARNING" == - ]] && WARNING=60
[[ -z "$CRITICAL"  "$CRITICAL" == -* ]] && CRITICAL=80

# Validate required variables,
if [[ -z "$HOST"  -z "$USER"  -z "$AUTH_PASS"  -z "$PRIV_PASS"  -z "$AUTH_PROTO"  -z "$PRIV_PROTO" ]]; then
  echo "UNKNOWN - Missing required arguments"
  exit 3
fi
# Detect device type using sysDescr,
SYS_DESCR=$(snmpget -v3 -u "$USER" -a "$AUTH_PROTO" -A "$AUTH_PASS" -x "$PRIV_PROTO" -X "$PRIV_PASS" -l authPriv "$HOST" SNMPv2-MIB::sysDescr.0 -Ovq 2>/dev/null)

if [[ -z "$SYS_DESCR" ]]; then
  echo "UNKNOWN - Unable to retrieve sysDescr"
  exit 3
fi

STATUS=0
CPU_SUMMARY=()

if echo "$SYS_DESCR" | grep -qi "BIG-IP"; then
  # F5 BIG-IP device
  # OIDs for F5 CPU cycle counters
  OID_TOTAL="1.3.6.1.4.1.3375.2.1.1.2.1.41"
  OID_IDLE="1.3.6.1.4.1.3375.2.1.1.2.1.42"
  OID_SLEEP="1.3.6.1.4.1.3375.2.1.1.2.1.43"

  # Get initial values
  TOTAL1=$(snmpwalk -v3 -u "$USER" -a "$AUTH_PROTO" -A "$AUTH_PASS" -x "$PRIV_PROTO" -X "$PRIV_PASS" -l authPriv "$HOST" "$OID_TOTAL" -Ovq)
  IDLE1=$(snmpwalk -v3 -u "$USER" -a "$AUTH_PROTO" -A "$AUTH_PASS" -x "$PRIV_PROTO" -X "$PRIV_PASS" -l authPriv "$HOST" "$OID_IDLE" -Ovq)
  SLEEP1=$(snmpwalk -v3 -u "$USER" -a "$AUTH_PROTO" -A "$AUTH_PASS" -x "$PRIV_PROTO" -X "$PRIV_PASS" -l authPriv "$HOST" "$OID_SLEEP" -Ovq)

  sleep 2

  # Get second values
  TOTAL2=$(snmpwalk -v3 -u "$USER" -a "$AUTH_PROTO" -A "$AUTH_PASS" -x "$PRIV_PROTO" -X "$PRIV_PASS" -l authPriv "$HOST" "$OID_TOTAL" -Ovq)
  IDLE2=$(snmpwalk -v3 -u "$USER" -a "$AUTH_PROTO" -A "$AUTH_PASS" -x "$PRIV_PROTO" -X "$PRIV_PASS" -l authPriv "$HOST" "$OID_IDLE" -Ovq)
  SLEEP2=$(snmpwalk -v3 -u "$USER" -a "$AUTH_PROTO" -A "$AUTH_PASS" -x "$PRIV_PROTO" -X "$PRIV_PASS" -l authPriv "$HOST" "$OID_SLEEP" -Ovq)

  # Calculate deltas
  DELTA_TOTAL=$((TOTAL2 - TOTAL1))
  DELTA_IDLE=$((IDLE2 - IDLE1))
  DELTA_SLEEP=$((SLEEP2 - SLEEP1))
  DELTA_USED=$((DELTA_TOTAL - DELTA_IDLE - DELTA_SLEEP))

  if (( DELTA_TOTAL > 0 )); then
    CPU_USAGE=$(awk "BEGIN {printf "%.2f", ($DELTA_USED / $DELTA_TOTAL) * 100}")
  else
    CPU_USAGE=0
  fi

  CPU_SUMMARY+=("TMM_CPU=${CPU_USAGE}%")

  if (( $(echo "$CPU_USAGE >= $CRITICAL" | bc -l) )); then
    STATUS=2
  elif (( $(echo "$CPU_USAGE >= $WARNING" | bc -l) )); then
    STATUS=1
  fi
else
  # Cisco device
  CPU_BASE_OID="1.3.6.1.4.1.9.9.109.1.1.1.1.7"
  CPU_OUTPUT=$(snmpwalk -v3 -u "$USER" -a "$AUTH_PROTO" -A "$AUTH_PASS" -x "$PRIV_PROTO" -X "$PRIV_PASS" -l authPriv "$HOST" "$CPU_BASE_OID" -On 2>/dev/null)

  if [[ -z "$CPU_OUTPUT" ]]; then
    echo "UNKNOWN - Unable to retrieve CPU usage"
    exit 3
  fi

  while read -r line; do
    index=$(echo "$line" | awk -F '.' '{print $NF}' | awk '{print $1}')
    value=$(echo "$line" | awk '{print $NF}')
    CPU_SUMMARY+=("CPU[$index]=$value%")

    if [[ "$value" =~ ^[0-9]+$ ]]; then
      if (( value >= CRITICAL )); then
        STATUS=2
      elif (( value >= WARNING && STATUS < 2 )); then
        STATUS=1
      fi
    fi
  done <<< "$CPU_OUTPUT"

fi

# Final status message
case $STATUS in
  2) STATUS_TEXT="CRITICAL" ;;
  1) STATUS_TEXT="WARNING" ;;
  ) STATUS_TEXT="OK" ;;
esac

echo "$STATUS_TEXT - ${CPU_SUMMARY[]}"
exit $STATUS

Python version

#!/usr/bin/env python3

import argparse
import subprocess
import sys
import time
import signal

STATUS_OK = 0
STATUS_WARNING = 1
STATUS_CRITICAL = 2
STATUS_UNKNOWN = 3
TIMEOUT_SECONDS = 60

def handle_timeout(signum, frame):
    print(f"UNKNOWN - Script timed out after {TIMEOUT_SECONDS} seconds")
    sys.exit(STATUS_UNKNOWN)

def snmpget(oid, args):
    cmd = [
        "snmpget", "-v3", "-u", args.user,
        "-a", args.auth_proto, "-A", args.auth_pass,
        "-x", args.priv_proto, "-X", args.priv_pass,
        "-l", "authPriv", args.host, oid, "-Ovq"
    ]
    try:
        out = subprocess.check_output(cmd, stderr=subprocess.DEVNULL, text=True).strip()
        if args.debug:
            print(f"DEBUG: snmpget {oid} → {out}")
        return out
    except:
        return ""

def snmpwalk(oid, args):
    cmd = [
        "snmpwalk", "-v3", "-u", args.user,
        "-a", args.auth_proto, "-A", args.auth_pass,
        "-x", args.priv_proto, "-X", args.priv_pass,
        "-l", "authPriv", args.host, oid, "-Ovq"
    ]
    try:
        out = subprocess.check_output(cmd, stderr=subprocess.DEVNULL, text=True).splitlines()
        if args.debug:
            print(f"DEBUG: snmpwalk {oid} → {out}")
        return out
    except:
        return []

def main():
    global TIMEOUT_SECONDS

    parser = argparse.ArgumentParser(description="SNMP CPU Usage Checker")
    parser.add_argument("-H", "--host", required=True)
    parser.add_argument("-u", "--user", required=True)
    parser.add_argument("-a", "--auth_pass", required=True)
    parser.add_argument("-p", "--priv_pass", required=True)
    parser.add_argument("-A", "--auth_proto", required=True, choices=["MD5", "SHA"])
    parser.add_argument("-X", "--priv_proto", required=True, choices=["DES", "AES"])
    parser.add_argument("-w", "--warning", type=float, default=60)
    parser.add_argument("-c", "--critical", type=float, default=80)
    parser.add_argument("--timeout", type=int, default=60)
    parser.add_argument("--debug", action="store_true")
    args = parser.parse_args()

    TIMEOUT_SECONDS = args.timeout
    signal.signal(signal.SIGALRM, handle_timeout)
    signal.alarm(TIMEOUT_SECONDS)

    sysdescr = snmpget("1.3.6.1.2.1.1.1.0", args)
    if not sysdescr:
        print("UNKNOWN - Unable to retrieve sysDescr")
        sys.exit(STATUS_UNKNOWN)

    if args.debug:
        print(f"DEBUG: sysDescr → {sysdescr}")

    status = STATUS_OK
    summary = []

    if "BIG-IP" in sysdescr:
        # F5 BIG-IP
        OID_TOTAL = "1.3.6.1.4.1.3375.2.1.1.2.1.41"
        OID_IDLE  = "1.3.6.1.4.1.3375.2.1.1.2.1.42"
        OID_SLEEP = "1.3.6.1.4.1.3375.2.1.1.2.1.43"

        t1 = list(map(int, snmpwalk(OID_TOTAL, args)))
        i1 = list(map(int, snmpwalk(OID_IDLE, args)))
        s1 = list(map(int, snmpwalk(OID_SLEEP, args)))
        time.sleep(2)
        t2 = list(map(int, snmpwalk(OID_TOTAL, args)))
        i2 = list(map(int, snmpwalk(OID_IDLE, args)))
        s2 = list(map(int, snmpwalk(OID_SLEEP, args)))

        if not (t1 and t2):
            print("UNKNOWN - Unable to retrieve F5 CPU counters")
            sys.exit(STATUS_UNKNOWN)

        for i in range(min(len(t1), len(t2))):
            dt = t2[i] - t1[i]
            di = i2[i] - i1[i]
            ds = s2[i] - s1[i]
            du = dt - di - ds
            usage = round((du / dt) * 100, 2) if dt > 0 else 0
            summary.append(f"TMM_CPU[{i}]={usage}%")
            if usage >= args.critical:
                status = STATUS_CRITICAL
            elif usage >= args.warning and status < STATUS_CRITICAL:
                status = STATUS_WARNING
    else:
        # Cisco device
        CPU_OID = "1.3.6.1.4.1.9.9.109.1.1.1.1.7"
        cpu_output = snmpwalk(CPU_OID, args)
        if not cpu_output:
            print("UNKNOWN - Unable to retrieve Cisco CPU usage")
            sys.exit(STATUS_UNKNOWN)
        for line in cpu_output:
            parts = line.strip().split()
            if len(parts) < 2:
                continue
            value = parts[-1]
            index = parts[0].split(".")[-1]
            if value.isdigit():
                val = int(value)
                summary.append(f"CPU[{index}]={val}%")
                if val >= args.critical:
                    status = STATUS_CRITICAL
                elif val >= args.warning and status < STATUS_CRITICAL:
                    status = STATUS_WARNING

    status_text = ["OK", "WARNING", "CRITICAL", "UNKNOWN"][status]
    print(f"{status_text} - {'; '.join(summary)}")
    sys.exit(status)

if __name__ == "__main__":
    main()