checks/mssql.include

   1 #!/usr/bin/python
   2 # -*- encoding: utf-8; py-indent-offset: 4 -*-
   3 # +------------------------------------------------------------------+
   4 # |             ____ _               _        __  __ _  __           |
   5 # |            / ___| |__   ___  ___| | __   |  \/  | |/ /           |
   6 # |           | |   | '_ \ / _ \/ __| |/ /   | |\/| | ' /            |
   7 # |           | |___| | | |  __/ (__|   <    | |  | | . \            |
   8 # |            \____|_| |_|\___|\___|_|\_\___|_|  |_|_|\_\           |
   9 # |                                                                  |
  10 # | Copyright Mathias Kettner 2016             mk@mathias-kettner.de |
  11 # +------------------------------------------------------------------+
  12 #
  13 # This file is part of Check_MK.
  14 # The official homepage is at http://mathias-kettner.de/check_mk.
  15 #
  16 # check_mk is free software;  you can redistribute it and/or modify it
  17 # under the  terms of the  GNU General Public License  as published by
  18 # the Free Software Foundation in version 2.  check_mk is  distributed
  19 # in the hope that it will be useful, but WITHOUT ANY WARRANTY;  with-
  20 # out even the implied warranty of  MERCHANTABILITY  or  FITNESS FOR A
  21 # PARTICULAR PURPOSE. See the  GNU General Public License for more de-
  22 # ails.  You should have  received  a copy of the  GNU  General Public
  23 # License along with GNU Make; see the file  COPYING.  If  not,  write
  24 # to the Free Software Foundation, Inc., 51 Franklin St,  Fifth Floor,
  25 # Boston, MA 02110-1301 USA.
  26
  27 #   .--helper--------------------------------------------------------------.
  28 #   |                    _          _                                      |
  29 #   |                   | |__   ___| |_ __   ___ _ __                      |
  30 #   |                   | '_ \ / _ \ | '_ \ / _ \ '__|                     |
  31 #   |                   | | | |  __/ | |_) |  __/ |                        |
  32 #   |                   |_| |_|\___|_| .__/ \___|_|                        |
  33 #   |                                |_|                                   |
  34 #   '----------------------------------------------------------------------'
  35
  36
  37 def _format_item_mssql_datafiles(inst, database, file_name):
  38     if inst is None:
  39         return "%s.%s" % (database, file_name)
  40     elif file_name is None:
  41         return "%s.%s" % (inst, database)
  42     return "%s.%s.%s" % (inst, database, file_name)
  43
  44
  45 def _mssql_datafiles_process_sizes(params, used_size, allocated_size, max_size, unlimited):
  46     def calculate_levels(levels, reference_value):
  47         if isinstance(levels[0], float):
  48             if reference_value != -1:
  49                 return [(x * reference_value) / 100 for x in levels]
  50         elif levels[0] is not None:
  51             return [x * 1024 * 1024 for x in levels]
  52
  53         return None, None
  54
  55     if unlimited:
  56         max_size = -1
  57
  58     rel_levels = False
  59
  60     for param_key, name, perf_key, value, reference_value in [
  61         ('used_levels', "used", "data_size", used_size, max_size),
  62         ('allocated_used_levels', "allocated used", None, used_size, allocated_size),
  63         ('allocated_levels', "allocated", "allocated_size", allocated_size, max_size),
  64     ]:
  65         status = 0
  66
  67         levels = params.get(param_key, (None, None))
  68         if isinstance(levels, list):
  69             warn, crit = None, None
  70             for level_set in levels:
  71                 if max_size > level_set[0]:
  72                     warn, crit = calculate_levels(level_set[1], reference_value)
  73                     break
  74         else:
  75             warn, crit = calculate_levels(levels, reference_value)
  76             if isinstance(levels[0], float):
  77                 rel_levels = True
  78
  79         if crit is not None and value >= crit:
  80             status = 2
  81         elif warn is not None and value >= warn:
  82             status = 1
  83
  84         if status > 0:
  85             wc_msg = " (warn/crit at %s/%s)" % (get_bytes_human_readable(warn),
  86                                                 get_bytes_human_readable(crit))
  87         else:
  88             wc_msg = ""
  89
  90         if perf_key is not None or status != 0:
  91             if reference_value == -1:
  92                 yield status, "%s %s%s" %\
  93                     (get_bytes_human_readable(value),
  94                         name, wc_msg), \
  95                     [(perf_key, value, warn, crit)]
  96             else:
  97                 yield status, "%s of %s %s%s" %\
  98                     (get_bytes_human_readable(value),
  99                         get_bytes_human_readable(reference_value),
 100                         name, wc_msg), \
 101                     [(perf_key, value, warn, crit, 0, reference_value)]
 102
 103     if unlimited and rel_levels:
 104         yield 0, "no maximum size", []
 105
 106
 107 #.
 108
 109 mssql_transactionlogs_discovery = []
 110
 111
 112 def parse_mssql_datafiles(info):
 113     parsed = {}
 114     for line in info:
 115         if len(line) == 8:
 116             inst, database, file_name, _physical_name, max_size, allocated_size, used_size, unlimited = line
 117             unlimited = unlimited == '1'
 118         else:
 119             database, file_name, _physical_name, max_size, allocated_size, used_size = line
 120             inst = None
 121             unlimited = False
 122
 123         mssql_instance = parsed.setdefault((inst, database, file_name), {"unlimited": unlimited})
 124         for key, value_str in [
 125             ("max_size", max_size),
 126             ("allocated_size", allocated_size),
 127             ("used_size", used_size),
 128         ]:
 129             try:
 130                 value = float(value_str) * 1024 * 1024
 131             except ValueError:
 132                 value = None
 133             mssql_instance[key] = value
 134     return parsed
 135
 136
 137 def inventory_mssql_datafiles(mode, parsed):
 138     settings = host_extra_conf(host_name(), mssql_transactionlogs_discovery)
 139     summarize = settings and settings[0].get("summarize_%s" % mode, False)
 140     for inst, database, file_name in parsed.iterkeys():
 141         if summarize:
 142             yield _format_item_mssql_datafiles(inst, database, None), {}
 143         else:
 144             yield _format_item_mssql_datafiles(inst, database, file_name), {}
 145
 146
 147 def check_mssql_datafiles(item, params, parsed):
 148     max_size_sum = 0
 149     allocated_size_sum = 0
 150     used_size_sum = 0
 151     unlimited_sum = False
 152
 153     found = False
 154     for (inst, database, file_name), values in parsed.iteritems():
 155         if _format_item_mssql_datafiles(inst, database, file_name) == item or \
 156                 _format_item_mssql_datafiles(inst, database, None) == item:
 157             found = True
 158             max_size = values["max_size"]
 159             allocated_size = values["allocated_size"]
 160             used_size = values["used_size"]
 161             if max_size:
 162                 max_size_sum += max_size
 163             if allocated_size:
 164                 allocated_size_sum += allocated_size
 165             if used_size:
 166                 used_size_sum += used_size
 167             unlimited_sum = unlimited_sum or values["unlimited"]
 168
 169     if not found:
 170         # Assume general connection problem to the database, which is reported
 171         # by the "X Instance" service and skip this check.
 172         raise MKCounterWrapped("Failed to connect to database")
 173
 174     return _mssql_datafiles_process_sizes(params, used_size_sum, allocated_size_sum, max_size_sum,
 175                                           unlimited_sum)