#!/usr/bin/python2

__author__ = 'forgodssake - https://github.com/forgodssake'
__version__ = 0.1

# The first section of the script is the sensors.py package

"""
@package sensors.py
Python Bindings for libsensors3

use the documentation of libsensors for the low level API.
see example.py for high level API usage.

@author: Pavel Rojtberg (http://www.rojtberg.net)
@see: https://github.com/paroj/sensors.py
@copyright: LGPLv2 (same as libsensors) <http://opensource.org/licenses/LGPL-2.1>
"""

from ctypes import *
import ctypes.util

_libc = cdll.LoadLibrary(ctypes.util.find_library("c"))
# see https://github.com/paroj/sensors.py/issues/1
_libc.free.argtypes = [c_void_p]

_hdl = cdll.LoadLibrary(ctypes.util.find_library("sensors"))

version = c_char_p.in_dll(_hdl, "libsensors_version").value.decode("ascii")


class bus_id(Structure):
    _fields_ = [("type", c_short),
                ("nr", c_short)]


class chip_name(Structure):
    _fields_ = [("prefix", c_char_p),
                ("bus", bus_id),
                ("addr", c_int),
                ("path", c_char_p)]


class feature(Structure):
    _fields_ = [("name", c_char_p),
                ("number", c_int),
                ("type", c_int)]

    # sensors_feature_type
    IN = 0x00
    FAN = 0x01
    TEMP = 0x02
    POWER = 0x03
    ENERGY = 0x04
    CURR = 0x05
    HUMIDITY = 0x06
    MAX_MAIN = 0x7
    VID = 0x10
    INTRUSION = 0x11
    MAX_OTHER = 0x12
    BEEP_ENABLE = 0x18


class subfeature(Structure):
    _fields_ = [("name", c_char_p),
                ("number", c_int),
                ("type", c_int),
                ("mapping", c_int),
                ("flags", c_uint)]


_hdl.sensors_get_detected_chips.restype = POINTER(chip_name)
_hdl.sensors_get_features.restype = POINTER(feature)
_hdl.sensors_get_all_subfeatures.restype = POINTER(subfeature)
_hdl.sensors_get_label.restype = c_void_p  # return pointer instead of str so we can free it
_hdl.sensors_get_adapter_name.restype = c_char_p  # docs do not say whether to free this or not
_hdl.sensors_strerror.restype = c_char_p

### RAW API ###
MODE_R = 1
MODE_W = 2
COMPUTE_MAPPING = 4


def init(cfg_file=None):
    file = _libc.fopen(cfg_file.encode("utf-8"), "r") if cfg_file is not None else None

    if _hdl.sensors_init(file) != 0:
        raise Exception("sensors_init failed")

    if file is not None:
        _libc.fclose(file)


def cleanup():
    _hdl.sensors_cleanup()


def parse_chip_name(orig_name):
    ret = chip_name()
    err = _hdl.sensors_parse_chip_name(orig_name.encode("utf-8"), byref(ret))

    if err < 0:
        raise Exception(strerror(err))

    return ret


def strerror(errnum):
    return _hdl.sensors_strerror(errnum).decode("utf-8")


def free_chip_name(chip):
    _hdl.sensors_free_chip_name(byref(chip))


def get_detected_chips(match, nr):
    """
    @return: (chip, next nr to query)
    """
    _nr = c_int(nr)

    if match is not None:
        match = byref(match)

    chip = _hdl.sensors_get_detected_chips(match, byref(_nr))
    chip = chip.contents if bool(chip) else None
    return chip, _nr.value


def chip_snprintf_name(chip, buffer_size=200):
    """
    @param buffer_size defaults to the size used in the sensors utility
    """
    ret = create_string_buffer(buffer_size)
    err = _hdl.sensors_snprintf_chip_name(ret, buffer_size, byref(chip))

    if err < 0:
        raise Exception(strerror(err))

    return ret.value.decode("utf-8")


def do_chip_sets(chip):
    """
    @attention this function was not tested
    """
    err = _hdl.sensors_do_chip_sets(byref(chip))
    if err < 0:
        raise Exception(strerror(err))


def get_adapter_name(bus):
    return _hdl.sensors_get_adapter_name(byref(bus)).decode("utf-8")


def get_features(chip, nr):
    """
    @return: (feature, next nr to query)
    """
    _nr = c_int(nr)
    feature = _hdl.sensors_get_features(byref(chip), byref(_nr))
    feature = feature.contents if bool(feature) else None
    return feature, _nr.value


def get_label(chip, feature):
    ptr = _hdl.sensors_get_label(byref(chip), byref(feature))
    val = cast(ptr, c_char_p).value.decode("utf-8")
    _libc.free(ptr)
    return val


def get_all_subfeatures(chip, feature, nr):
    """
    @return: (subfeature, next nr to query)
    """
    _nr = c_int(nr)
    subfeature = _hdl.sensors_get_all_subfeatures(byref(chip), byref(feature), byref(_nr))
    subfeature = subfeature.contents if bool(subfeature) else None
    return subfeature, _nr.value


def get_value(chip, subfeature_nr):
    val = c_double()
    err = _hdl.sensors_get_value(byref(chip), subfeature_nr, byref(val))
    if err < 0:
        raise Exception(strerror(err))
    return val.value


def set_value(chip, subfeature_nr, value):
    """
    @attention this function was not tested
    """
    val = c_double(value)
    err = _hdl.sensors_set_value(byref(chip), subfeature_nr, byref(val))
    if err < 0:
        raise Exception(strerror(err))


### Convenience API ###
class ChipIterator:
    def __init__(self, match=None):
        self.match = parse_chip_name(match) if match is not None else None
        self.nr = 0

    def __iter__(self):
        return self

    def __next__(self):
        chip, self.nr = get_detected_chips(self.match, self.nr)

        if chip is None:
            raise StopIteration

        return chip

    def __del__(self):
        if self.match is not None:
            free_chip_name(self.match)

    def next(self):  # python2 compability
        return self.__next__()


class FeatureIterator:
    def __init__(self, chip):
        self.chip = chip
        self.nr = 0

    def __iter__(self):
        return self

    def __next__(self):
        feature, self.nr = get_features(self.chip, self.nr)

        if feature is None:
            raise StopIteration

        return feature

    def next(self):  # python2 compability
        return self.__next__()


class SubFeatureIterator:
    def __init__(self, chip, feature):
        self.chip = chip
        self.feature = feature
        self.nr = 0

    def __iter__(self):
        return self

    def __next__(self):
        subfeature, self.nr = get_all_subfeatures(self.chip, self.feature, self.nr)

        if subfeature is None:
            raise StopIteration

        return subfeature

    def next(self):  # python2 compability
        return self.__next__()

# End of sensors.py

def check_threshold(threshold):
    # check if first char is - or + and the rest an integer
    if threshold[:1] == '+' or threshold[:1] == '-':
        try:
            return 'rel',int(threshold)
        except:
            nice_exit(2, "Critical - {0} is not a valid threshold".format(threshold))

    # try returning it as integer, in that case it's an absolute value
    try:
        return 'abs',int(threshold)
    except:
        nice_exit(2, "Critical - Please provide a valid threshold")

def restricted_float(x):
    x = float(x)
    if x < 0.0 or x > 1.0:
        raise argparse.ArgumentTypeError("%r not in range [0.0, 1.0]"%(x,))
    return x

def get_chip_values_coretemp(chip):
    max_tmp = 0
    sen_high = 99999 # I guess all cores should have same limits but just in case
    sen_crit = 99999
    for feature in FeatureIterator(chip):
        sfs = list(SubFeatureIterator(chip, feature))  # get a list of all subfeatures
        # Get temperature
        vals = [get_value(chip, sf.number) for sf in sfs]

        max_tmp = max(int(vals[0]),max_tmp)
        sen_high = min(int(vals[1]), sen_high)
        sen_crit = min(int(vals[2]), sen_crit)

    return max_tmp, sen_high, sen_crit

def get_chip_values_nct6779(chip):
    max_tmp = 0
    sen_high = 99999 # I guess all cores should have same limits but just in case
    for feature in FeatureIterator(chip):
        sfs = list(SubFeatureIterator(chip, feature))  # get a list of all subfeatures
        # Get temperature
        vals = [get_value(chip, sf.number) for sf in sfs]

        # Ugly, but I couldn't find a more reliable way to detect
        # CPU temperature values. This should match both SYSTIN and CPUTIN.
        if (feature.type != feature.TEMP or len(vals) != 7):
            continue

        # SYSTIN has 0 as HIGH/HYST values
        if ((int(vals[1]) <= 0) or (int(vals[2]) <= 0)):
            continue

        # vals[0] = cpu temperature
        # vals[1] = hysteresis value (useless)
        # vals[2] = high temperature value
        max_tmp = max(int(round(vals[0])),max_tmp)
        sen_high = min(int(round(vals[2])), sen_high)

    # Calculate critical temperature from that provided by the sensor
    sen_crit = max(0, sen_high + 20)
    return max_tmp, sen_high, sen_crit

def main():
    try:
        import argparse
    except ImportError:
        nice_exit(2, "CRITICAL - argparse module not found")

    # Parse script arguments
    parser = argparse.ArgumentParser('Check cpu temperature using sensors package.\n'
                                     'Auto detection sets warning threshold to high limit provided by sensors.\n'
                                     'Critical threshold between high and critical limit provided by sensors (controled by ratio paramenter, 0.5 is the default).\n'
                                     'Relative thresholds are calculated based on auto detected values.')
    parser.add_argument('-c', '--critical', action='store', default='',
                        help="Sets critical threshold. Also accepts relative values (-2,+2, ..). Leave empty for auto-detect.")
    parser.add_argument('-w', '--warning', action='store', default='',
                        help="Sets warning threshold. Also accepts relative values (-2,+2, ..). Leave empty for auto-detect")
    parser.add_argument('-r', '--ratio', action='store', default='0.5', type=restricted_float,
                        help="Sets the ratio between high and critical values for auto detect critical threshold.")
    args = parser.parse_args()

    # Can't autodetect warning, should be absolute or relative
    if args.warning == '':
        w_action = 'auto'
        w_val = 0
    else:
        w_action,w_val = check_threshold(args.warning)

    # Empty critical means auto detection
    if args.critical == '':
        c_action = 'auto'
        c_val = 0
    else:
        c_action,c_val = check_threshold(args.critical)

    # Declare vars
    nagios_status = 0 # OK by default
    nagios_msg = []
    nagios_performance = []
    cpu_id = 0

    # Detect temperature
    init()  # optionally takes config file

    for chip in ChipIterator():  # optional arg like "coretemp-*" restricts iterator
        # To support a new chip just create a new function for it
        cb = "get_chip_values_" + chip.prefix
        if not cb in globals():
            continue

        # Calls get_chip_values_* callback function
        # So chip logic can be implemented separately
        max_tmp, sen_high, sen_crit = globals()[cb](chip)

        # Time to calculate the real warning and critical thresholds
        sen_crit_auto = int(abs((sen_crit - sen_high)*args.ratio)+sen_high)
        if c_action == 'auto': real_crit = sen_crit_auto
        if c_action == 'abs': real_crit = c_val
        if c_action == 'rel': real_crit = sen_crit_auto + c_val

        if w_action == 'auto': real_warn = sen_high
        if w_action == 'abs': real_warn = w_val
        if w_action == 'rel': real_warn = sen_high + w_val

        # Now that we have the real crit and warn, verify that warn isn't higher than crit
        if real_warn > real_crit:
            nice_exit(2, "CRITICAL - Warning threshold can't be higher than critical (w: {0}, c:{1}".format(real_warn, real_crit))

        # Now that we have the max temp per cpu and min crit, see if we are in trouble
        if max_tmp > real_crit:
            nagios_status = 2 # Set as critical
        elif max_tmp > real_warn:
            nagios_status = max(nagios_status, 1) # set warning if it wasn't on critical

        nagios_msg.append("CPU {0}({1})".format(cpu_id, max_tmp))
        nagios_performance.append('CPU_{0}={1};{2};{3}'.format(cpu_id, max_tmp,real_warn, real_crit))

        # Increase the cpu counter
        cpu_id +=1
    cleanup()

    # Final message print
    nagios_return_codes = {
        0: 'OK',
        1: 'WARNING',
        2: 'CRITICAL',
    }

    if nagios_msg == []:
        nice_exit(2,'CRITICAL - No sensors detected')

    final_message = '{0} - {1} | {2}'.format(nagios_return_codes[nagios_status], ', '.join(nagios_msg), ', '.join(nagios_performance))

    nice_exit(nagios_status, final_message)

def nice_exit(exitcode, message=''):
    """ Exit gracefully with exitcode and (optional) message """

    if message:
        print(message)
    exit(exitcode)


if __name__ == '__main__':
    main()
