cmk_nsx/local/share/check_mk/checks/check_nsx

432 lines
19 KiB
Plaintext
Raw Normal View History

2018-12-27 12:24:34 +02:00
#!/usr/bin/python
# -*- encoding: utf-8; py-indent-offset: 4 -*-
# +------------------------------------------------------------------+
# | ____ _ _ __ __ _ __ |
# | / ___| |__ ___ ___| | __ | \/ | |/ / |
# | | | | '_ \ / _ \/ __| |/ / | |\/| | ' / |
# | | |___| | | | __/ (__| < | | | | . \ |
# | \____|_| |_|\___|\___|_|\_\___|_| |_|_|\_\ |
# | |
# | Copyright Mathias Kettner 2018 mk@mathias-kettner.de |
# +------------------------------------------------------------------+
#
# This file is part of Check_MK.
# The official homepage is at http://mathias-kettner.de/check_mk.
#
# check_mk is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation in version 2. check_mk is distributed
# in the hope that it will be useful, but WITHOUT ANY WARRANTY; with-
# out even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE. See the GNU General Public License for more de-
# tails. You should have received a copy of the GNU General Public
# License along with GNU Make; see the file COPYING. If not, write
# to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
# Boston, MA 02110-1301 USA.
import datetime
def inventory_edges_status(info):
for name, edgeid, edgestatus, edgestate, edgetype in info:
yield ("Edge %s" % \
(edgeid), {})
def check_edges_status(item, params, info):
for line in info:
edge = "Edge" + " " + line[1]
if edge==item:
edgename = line[0]
edgestatus = line[2]
edgestate = line[3]
edgetype = line[4]
if edgetype == "distributedRouter":
if edgestate != "active":
return 2, "Edge %s state is %s and status %s" % (edgename, edgestate, edgestatus )
elif edgestatus == "GREEN":
return 0, "Edge %s state is %s and status %s" % (edgename, edgestate, edgestatus )
elif edgestatus == "GREY":
return 0, "Edge %s state is %s and status %s" % (edgename, edgestate, edgestatus )
elif edgestatus == "YELLOW":
return 1, "Edge %s state is %s and status %s" % (edgename, edgestate, edgestatus )
elif edgestatus == "RED":
return 2, "Edge %s state is %s and status %s" % (edgename, edgestate, edgestatus )
return 3, "Edge %s state is %s and status %s" % (edgename, edgestate, edgestatus )
else:
if edgestatus == "GREEN":
return 0, "Edge %s is %s" % (edgename, edgestatus)
elif edgestatus == "YELLOW":
return 1, "Edge %s is %s" % (edgename, edgestatus)
elif edgestatus == "RED":
return 2, "Edge %s is %s" % (edgename, edgestatus)
return 3, "Edge %s is %s" % (edgename, edgestatus)
check_info['nsx_edges'] = {
'inventory_function' : inventory_edges_status,
'check_function' : check_edges_status,
'service_description' : '%s',
'has_perfdata' : False,
}
#.
# .--Controller Status---------------------------------------------------.
# | ____ _ _ _ |
# | / ___|___ _ __ | |_ _ __ ___ | | | ___ _ __ |
# | | | / _ \| '_ \| __| '__/ _ \| | |/ _ \ '__| |
# | | |__| (_) | | | | |_| | | (_) | | | __/ | |
# | \____\___/|_| |_|\__|_| \___/|_|_|\___|_| |
# | |
# | ____ _ _ |
# | / ___|| |_ __ _| |_ _ _ ___ |
# | \___ \| __/ _` | __| | | / __| |
# | ___) | || (_| | |_| |_| \__ \ |
# | |____/ \__\__,_|\__|\__,_|___/ |
# | |
# +----------------------------------------------------------------------+
# | |
# '----------------------------------------------------------------------'
def inventory_controller_status(info):
for name, id, status in info:
yield ("Controller %s" % \
(id), {})
def check_controller_status(item, params, info):
for line in info:
controller = "Controller" + " " + line[1]
if controller==item:
controllername = line[0]
controllerstatus = line[2]
if controllerstatus == "RUNNING":
return 0, "Controller %s is %s" % (controllername, controllerstatus)
elif controllerstatus == "DEPLOYING":
return 1, "Controller %s is %s" % (controllername, controllerstatus)
elif controllerstatus == "REMOVING":
return 1, "Controller %s is %s" % (controllername, controllerstatus)
elif controllerstatus == "UNKNOWN":
return 2, "Controller %s is %s" % (controllername, controllerstatus)
check_info['nsx_controller'] = {
'inventory_function' : inventory_controller_status,
'check_function' : check_controller_status,
'service_description' : '%s',
'has_perfdata' : False,
}
#.
# .--NSX Components------------------------------------------------------.
# | _ _ ______ __ |
# | | \ | / ___\ \/ / |
# | | \| \___ \\ / |
# | | |\ |___) / \ |
# | |_| \_|____/_/\_\ |
# | |
# | ____ _ |
# | / ___|___ _ __ ___ _ __ ___ _ __ ___ _ __ | |_ ___ |
# | | | / _ \| '_ ` _ \| '_ \ / _ \| '_ \ / _ \ '_ \| __/ __| |
# | | |__| (_) | | | | | | |_) | (_) | | | | __/ | | | |_\__ \ |
# | \____\___/|_| |_| |_| .__/ \___/|_| |_|\___|_| |_|\__|___/ |
# | |_| |
# +----------------------------------------------------------------------+
# | |
# '----------------------------------------------------------------------'
def inventory_nsx_components(info):
for name, id, status in info:
yield ("Component %s" % \
(id), {})
def check_nsx_components(item, params, info):
for line in info:
component = "Component" + " " + line[1]
if component==item:
component_name = line[0]
component_status = line[2]
if component_status == "RUNNING":
return 0, "Component %s is %s" % (component_name, component_status)
else:
return 2, "Component %s is %s" % (component_name, component_status)
check_info['nsx_components'] = {
'inventory_function' : inventory_nsx_components,
'check_function' : check_nsx_components,
'service_description' : '%s',
'has_perfdata' : False,
}
#.
# .--NSX Backup----------------------------------------------------------.
# | _ _ ______ __ ____ _ |
# | | \ | / ___\ \/ / | __ ) __ _ ___| | ___ _ _ __ |
# | | \| \___ \\ / | _ \ / _` |/ __| |/ / | | | '_ \ |
# | | |\ |___) / \ | |_) | (_| | (__| <| |_| | |_) | |
# | |_| \_|____/_/\_\ |____/ \__,_|\___|_|\_\\__,_| .__/ |
# | |_| |
# +----------------------------------------------------------------------+
# | |
# '----------------------------------------------------------------------'
def inventory_nsx_backups(info):
return [(None, {})]
def check_nsx_backup(item, params, info):
warn, crit = params
if info:
last_backup = sorted(info, key=lambda tup: tup[2])[-1]
last_backup_size = last_backup[1]
last_backup_time = datetime.datetime.fromtimestamp(float(last_backup[2])/1000)
elapsed = datetime.datetime.now() - last_backup_time
if elapsed >= datetime.timedelta(days=crit):
return 2, "Last backup was taken more than %s days ago. Last backup date is %s " \
% (crit, last_backup_time)
elif elapsed >= datetime.timedelta(days=warn):
return 1, "Last backup was taken more than %s days ago. Last backup date is %s " \
% (warn, last_backup_time)
else:
return 0, "Date of last backup is %s" % last_backup_time
else:
return 3, "Backup not available"
check_info['nsx_backup'] = {
'inventory_function' : inventory_nsx_backups,
'check_function' : check_nsx_backup,
'service_description' : 'NSX Backups',
'has_perfdata' : False,
'group' : "backups",
}
#.
# .--Memory--------------------------------------------------------------.
# | __ __ |
# | | \/ | ___ _ __ ___ ___ _ __ _ _ |
# | | |\/| |/ _ \ '_ ` _ \ / _ \| '__| | | | |
# | | | | | __/ | | | | | (_) | | | |_| | |
# | |_| |_|\___|_| |_| |_|\___/|_| \__, | |
# | |___/ |
# +----------------------------------------------------------------------+
nsx_memory_default_levels = ( 80.0, 90.0 )
def nsx_convert(info):
data = {}
for line in info:
data[line[0]] = line[1:]
return data
def inventory_nsx_mem(info):
data = nsx_convert(info)
return [(None, 'nsx_mem_default_levels')]
def check_nsx_mem(item, params, info):
data = nsx_convert(info)
warn, crit = params
memory_usage = savefloat(data['UsedMemory'][0]) * 1024 * 1024
memory_size = savefloat(data['TotalMem'][0]) * 1024 * 1024
level = savefloat(data['UsedPercentage'][0])
state = 0
label = ''
if level >= crit:
state = 2
label = " (Levels at %d%%/%d%%)" % (warn, crit)
elif level >= warn:
state = 1
label = " (Levels at %d%%/%d%%)" % (warn, crit)
message = "%d%%%s used - %s/%s" % \
(level, label, get_bytes_human_readable(memory_usage), get_bytes_human_readable(memory_size))
perf = [("mem_used", memory_usage, warn * memory_size / 100, crit * memory_size / 100, 0, memory_size),
("mem_total", memory_size)]
return(state, message, perf)
check_info['nsx_memory'] = {
"inventory_function" : inventory_nsx_mem,
"check_function" : check_nsx_mem,
"service_description" : "Memory used",
"group" : "nsx_memory",
"has_perfdata" : True,
"default_levels_variable" : "nsx_mem_default_levels"
}
#.
# .--CPU-----------------------------------------------------------------.
# | ____ ____ _ _ |
# | / ___| _ \| | | | |
# | | | | |_) | | | | |
# | | |___| __/| |_| | |
# | \____|_| \___/ |
# | |
# +----------------------------------------------------------------------+
nsx_host_cpu_default_levels = {}
def inventory_nsx_cpu(info):
data = nsx_convert(info).keys()
if 'usedPercentage' in data \
and 'totalNoOfCPUs' in data\
and 'capacity' in data:
return [(None, {})]
def check_nsx_cpu(item, params, info):
data = nsx_convert(info)
if "usedPercentage" not in data:
return
#Asuming that there are 1 thread per core and one core per socket
#Asuming that capacity represents total capacity
num_cpu = int(data['totalNoOfCPUs'][0])
total_capacity = int(data['capacity'][0])
used_capacity = float(data['usedCapacity'][0])
mhz_per_core = float(data['capacity'][0]) / num_cpu
usage = used_capacity / total_capacity * 100
per_core = num_cpu / 100.0
infotext = "%.1f%%" % usage
# Convert legacy parameters
this_time = time.time()
state, infotext, perfdata = check_cpu_util(usage, params).next()
infotext += ", %.2fGHz/%.2fGHz" % (used_capacity / 1000.0, total_capacity / 1000.0)
infotext += ", %d sockets, %d cores/socket, %d threads" % (
num_cpu, 1 , 1)
return (state, infotext, perfdata)
check_info['nsx_cpu'] = {
"inventory_function" : inventory_nsx_cpu,
"check_function" : check_nsx_cpu,
"service_description" : "CPU utilization",
"group" : "cpu_utilization_os",
"has_perfdata" : True,
"default_levels_variable" : "nsx_host_cpu_default_levels",
"includes" : [ "cpu_util.include" ],
}
#.
# .--NSX vCenter Connection----------------------------------------------.
# | _ _ ______ __ ____ _ |
# | | \ | / ___\ \/ / __ __/ ___|___ _ __ | |_ ___ _ __ |
# | | \| \___ \\ / \ \ / / | / _ \ '_ \| __/ _ \ '__| |
# | | |\ |___) / \ \ V /| |__| __/ | | | || __/ | |
# | |_| \_|____/_/\_\ \_/ \____\___|_| |_|\__\___|_| |
# | |
# | ____ _ _ |
# | / ___|___ _ __ _ __ ___ ___| |_(_) ___ _ __ |
# | | | / _ \| '_ \| '_ \ / _ \/ __| __| |/ _ \| '_ \ |
# | | |__| (_) | | | | | | | __/ (__| |_| | (_) | | | | |
# | \____\___/|_| |_|_| |_|\___|\___|\__|_|\___/|_| |_| |
# | |
# +----------------------------------------------------------------------+
# | |
# '----------------------------------------------------------------------'
def inventory_nsx_vcenter_connection(info):
return [(None, {})]
def check_nsx_vcenter_connection(item, params, info):
if "true" in info[0]:
return 0, "vCenterConnection is true"
elif "false" in info[0]:
return 2, "vCenterConnection is false"
check_info['nsx_vcenter_connection'] = {
'inventory_function' : inventory_nsx_vcenter_connection,
'check_function' : check_nsx_vcenter_connection,
'service_description' : 'vCenter Connection',
'has_perfdata' : False,
}
#.
# .--NSX Storage Info----------------------------------------------------.
# | _ _ ______ __ ____ _ |
# | | \ | / ___\ \/ / / ___|| |_ ___ _ __ __ _ __ _ ___ |
# | | \| \___ \\ / \___ \| __/ _ \| '__/ _` |/ _` |/ _ \ |
# | | |\ |___) / \ ___) | || (_) | | | (_| | (_| | __/ |
# | |_| \_|____/_/\_\ |____/ \__\___/|_| \__,_|\__, |\___| |
# | |___/ |
# | ___ __ |
# | |_ _|_ __ / _| ___ |
# | | || '_ \| |_ / _ \ |
# | | || | | | _| (_) | |
# | |___|_| |_|_| \___/ |
# | |
# +----------------------------------------------------------------------+
# | |
# '----------------------------------------------------------------------'
nsx_storage_default_levels = ( 70.0, 80.0 )
def inventory_nsx_storage(info):
data = nsx_convert(info)
return [(None, 'nsx_storage_default_levels')]
def check_nsx_storage(item, params, info):
warn,crit = params
data = nsx_convert(info)
used_storage = float(re.sub('G','', data['UsedStorage'][0],count =1))
total_storage = float(re.sub('G','', data['TotalStorage'][0],count =1))
free_storage = float(re.sub('G','', data['FreeStorage'][0],count =1))
used_percentage = float(re.sub('G','', data['UsedPercentage'][0],count =1))
perf = [("storage_used", used_storage * 1024 * 1024 * 1024, \
warn * total_storage * 1024 * 1024 * 1024 / 100 , \
crit * total_storage * 1024 * 1024 * 1024 / 100 , 0, total_storage * 1024 * 1024 * 1024)]
if used_percentage >= crit:
return 2, "Storage used is %sGB out of %sGB" % (used_storage, total_storage) , perf
elif used_percentage >= warn:
return 1, "Storage used is %sGB out of %sGB" % (used_storage, total_storage) , perf
else:
return 0, "Storage used is %sGB out of %sGB" % (used_storage, total_storage) , perf
check_info['nsx_storage_info'] = {
"inventory_function" : inventory_nsx_storage,
"check_function" : check_nsx_storage,
"service_description" : "Storage used",
"group" : "nsx_storage",
"has_perfdata" : True,
"default_levels_variable" : "nsx_storage_default_levels",
}
####NSX_RESOURCES
def inventory_nsx_resources(info):
for domain_name, component, status in info:
component_sn = component.split(".")[-1]
yield ("%s %s" % \
(domain_name, component_sn), {})
def check_nsx_resources(item, params, info):
for line in info:
component = line[0] + " " + line[1].split(".")[-1]
if component==item:
domain_name = line[0]
component_name = line[1].split(".")[-1]
component_status = line[2]
if component_name == "hostRebootRequired":
if component_status == "false":
return 0, "Host reboot is not required. "
else:
return 1, "Host needs a reboot"
if component_status == "GREEN":
return 0, "Component %s is %s" % (component_name, component_status)
elif component_status =="UNKNOWN":
return 3, "Status is unknown"
else:
return 2, "Component %s is %s" % (component_name, component_status)
check_info['nsx_resources'] = {
'inventory_function' : inventory_nsx_resources,
'check_function' : check_nsx_resources,
'service_description' : '%s',
'has_perfdata' : False,
}