Module: check_mk Branch: master Commit: 3be851a23147ef8902c5b12d1115daee7cbdee5b URL: http://git.mathias-kettner.de/git/?p=check_mk.git;a=commit;h=3be851a23147ef… Author: Andreas Boesl &lt;ab(a)mathias-kettner.de&gt; Date: Thu Aug 22 16:22:45 2013 +0200 df / esx_vsphere_datastore easier filesystem level configuration --- ChangeLog | 3 ++ checks/df.include | 62 +++++++++++++++++++++++++++++----- web/plugins/wato/check_parameters.py | 62 ++++++++++++++++++++++++++++++---- 3 files changed, 112 insertions(+), 15 deletions(-) diff --git a/ChangeLog b/ChangeLog index 70b4a46..3df43a9 100644 --- a/ChangeLog +++ b/ChangeLog @@ -66,6 +66,9 @@ (output buffer now grows dynamically) * jolokia_metrics: fixed incorrect plugin output for high warn/crit levels * hyperv: Added a check for checking state changes. + * df / esx_vsphere_datastore: filesystem levels configuration gets even easier + now able to set absolute levels and levels depending + on total disk space Notifications: * notify.py: Matching service level: Use the hosts service level if a diff --git a/checks/df.include b/checks/df.include index e3495ec..24f3626 100644 --- a/checks/df.include +++ b/checks/df.include @@ -55,9 +55,9 @@ filesystem_groups = [] # } factory_settings["filesystem_default_levels"] = { - "levels" : (80, 90), # warn/crit in percent + "levels" : (80.0, 90.0), # warn/crit in percent "magic_normsize" : 20, # Standard size if 20 GB - "levels_low" : (50, 60), # Never move warn level below 50% due to magic factor + "levels_low" : (50.0, 60.0), # Never move warn level below 50% due to magic factor "trend_range" : 24, "trend_perfdata" : True, # do send performance data for trends } @@ -101,16 +101,28 @@ def df_inventory(mplist): # old style params a'la (80, 90). As soon as we drop support for that # (can happen any decade now), we can get rid of this function. def get_filesystem_levels(host, mountpoint, size_gb, params): - + mega = 1024 * 1024 + giga = mega * 1024 # Start with factory settings levels = factory_settings["filesystem_default_levels"].copy() + + def convert_legacy_levels(value): + if type(params) == tuple or not params.get("flex_levels"): + return tuple(map(float, value)) + else: + return value + # convert default levels to dictionary. This is in order support # old style levels like (80, 90) if type(filesystem_default_levels) == dict: + fs_default_levels = filesystem_default_levels.copy() + fs_levels = fs_default_levels.get("levels") + if fs_levels: + fs_default_levels["levels"] = convert_legacy_levels(fs_levels) levels.update(filesystem_default_levels) else: levels = factory_settings["filesystem_default_levels"].copy() - levels["levels"] = filesystem_default_levels[:2] + levels["levels"] = convert_legacy_levels(filesystem_default_levels[:2]) if len(filesystem_default_levels) == 2: levels["magic"] = None else: @@ -121,16 +133,35 @@ def get_filesystem_levels(host, mountpoint, size_gb, params): levels.update(params) else: # simple format - explicitely override levels and magic - levels["levels"] = params[:2] + levels["levels"] = convert_legacy_levels(params[:2]) if len(params) >= 3: levels["magic"] = params[2] - warn, crit = levels["levels"] + # Determine real warn, crit levels + if type(levels["levels"]) == tuple: + warn, crit = levels["levels"] + else: + # A list of levels. Choose the correct one depending on the + # size of the current tablespace + found = False + for to_size, this_levels in levels["levels"]: + if size_gb * giga > to_size: + warn, crit = this_levels + found = True + if not found: + warn, crit = 100.0, 100.0 # entry not found in list + # If the magic factor is used, take disk size and magic factor # into account in order to move levels magic = levels.get("magic") if magic: + # convert warn/crit to percentage + if type(warn) != float: + warn = savefloat(warn * mega / float(size_gb * giga)) * 100 + if type(crit) != float: + crit = savefloat(crit * mega / float(size_gb * giga)) * 100 + normsize = levels["magic_normsize"] hgb_size = size_gb / float(normsize) felt_size = hgb_size ** magic @@ -145,14 +176,27 @@ def get_filesystem_levels(host, mountpoint, size_gb, params): if crit_scaled < lowest_critical_level: crit_scaled = lowest_critical_level else: - warn_scaled = warn - crit_scaled = crit + if type(warn) != float: + warn_scaled = savefloat(warn * mega / float(size_gb * giga)) * 100 + else: + warn_scaled = warn + + if type(crit) != float: + crit_scaled = savefloat(crit * mega / float(size_gb * giga)) * 100 + else: + crit_scaled = crit size_mb = size_gb * 1024 warn_mb = savefloat(size_mb * warn_scaled / 100) crit_mb = savefloat(size_mb * crit_scaled / 100) levels["levels_mb"] = (warn_mb, crit_mb) - levels["levels_text"] = "(levels at %.1f/%.1f%%)" % (warn_scaled, crit_scaled) + if type(warn) == float: + levels["levels_text"] = "(levels at %.2f/%.2f%%)" % (warn_scaled, crit_scaled) + else: + warn_hr = get_bytes_human_readable(warn * mega) + crit_hr = get_bytes_human_readable(crit * mega) + levels["levels_text"] = "(levels at %s/%s)" % ( warn_hr, crit_hr ) + return levels # Legacy function for checks that do not support groups yet diff --git a/web/plugins/wato/check_parameters.py b/web/plugins/wato/check_parameters.py index 467ee10..a23ba31 100644 --- a/web/plugins/wato/check_parameters.py +++ b/web/plugins/wato/check_parameters.py @@ -1322,12 +1322,60 @@ register_check_parameters( ) filesystem_elements = [ - ( "levels", - Tuple( - title = _("Levels for filesystem usage"), - elements = [ - Percentage(title = _("Warning if above"), unit = _("% usage"), allow_int = True, default_value=80), - Percentage(title = _("Critical if above"), unit = _("% usage"), allow_int = True, default_value=90)])), + ("levels", + Alternative( + title = _("Levels for filesystem usage"), + default_value = (80.0, 90.0), + elements = [ + Tuple( + title = _("Percentage used space"), + elements = [ + Percentage(title = _("Warning if above"), unit = _("% usage")), + Percentage(title = _("Critical if above"), unit = _("% usage")), + ] + ), + Tuple( + title = _("Absolute used space"), + elements = [ + Integer(title = _("Warning if above"), unit = _("MB")), + Integer(title = _("Critical if above"), unit = _("MB")), + ] + ), + ListOf( + Tuple( + orientation = "horizontal", + elements = [ + Filesize(title = _("Filesystem larger than")), + Alternative( + title = _("Levels for the filesystem usage"), + elements = [ + Tuple( + title = _("Percentage used space"), + elements = [ + Percentage(title = _("Warning if above"), unit = _("% usage")), + Percentage(title = _("Critical if above"), unit = _("% usage")), + ] + ), + Tuple( + title = _("Absolute used space"), + elements = [ + Integer(title = _("Warning if above"), unit = _("MB")), + Integer(title = _("Critical if above"), unit = _("MB")), + ] + ), + ] + ), + ], + ), + title = _('Dynamic levels'), + ),]), + ), + ( "flex_levels", + FixedValue( + None, + totext = "", + title = _("Hidden identifier key for flexible level usage") + )), ( "magic", Float( title = _("Magic factor (automatic level adaptation for large filesystems)"), @@ -1390,6 +1438,7 @@ register_check_parameters( _("Filesystems (used space and growth)"), Dictionary( elements = filesystem_elements, + hidden_keys = ["flex_levels"], ), TextAscii( title = _("Mount point"), @@ -1414,6 +1463,7 @@ register_check_parameters( ] )), ], + hidden_keys = ["flex_levels"], ), TextAscii( title = _("Datastore Name"),