thresholds.go

package monitoringplugin

import (
	"fmt"
	"github.com/pkg/errors"
	"math/big"
	"strconv"
)

// Thresholds contains all threshold values
type Thresholds struct {
	WarningMin  interface{} `json:"warningMin" xml:"warningMin"`
	WarningMax  interface{} `json:"warningMax" xml:"warningMax"`
	CriticalMin interface{} `json:"criticalMin" xml:"criticalMin"`
	CriticalMax interface{} `json:"criticalMax" xml:"criticalMax"`
}

// NewThresholds creates a new threshold
func NewThresholds(warningMin, warningMax, criticalMin, criticalMax interface{}) Thresholds {
	return Thresholds{
		WarningMin:  warningMin,
		WarningMax:  warningMax,
		CriticalMin: criticalMin,
		CriticalMax: criticalMax,
	}
}

// Validate checks if the Thresholds contains some invalid combination of warning and critical values
func (c *Thresholds) Validate() error {
	if c.WarningMin != nil && c.WarningMax != nil {
		var min, max big.Float
		_, _, err := min.Parse(fmt.Sprint(c.WarningMin), 10)
		if err != nil {
			return errors.Wrap(err, "can't parse warning min")
		}
		_, _, err = max.Parse(fmt.Sprint(c.WarningMax), 10)
		if err != nil {
			return errors.Wrap(err, "can't parse warning max")
		}

		if res := min.Cmp(&max); res == 1 {
			return errors.New("warning min and max are invalid")
		}
	}

	if c.CriticalMin != nil && c.CriticalMax != nil {
		var min, max big.Float
		_, _, err := min.Parse(fmt.Sprint(c.CriticalMin), 10)
		if err != nil {
			return errors.Wrap(err, "can't parse critical min")
		}
		_, _, err = max.Parse(fmt.Sprint(c.CriticalMax), 10)
		if err != nil {
			return errors.Wrap(err, "can't parse critical max")
		}

		if res := min.Cmp(&max); res == 1 {
			return errors.New("critical min and max are invalid")
		}
	}

	if c.CriticalMin != nil && c.WarningMin != nil {
		var wMin, cMin big.Float
		_, _, err := wMin.Parse(fmt.Sprint(c.WarningMin), 10)
		if err != nil {
			return errors.Wrap(err, "can't parse warning min")
		}
		_, _, err = cMin.Parse(fmt.Sprint(c.CriticalMin), 10)
		if err != nil {
			return errors.Wrap(err, "can't parse critical min")
		}

		if res := cMin.Cmp(&wMin); res == 1 {
			return errors.New("critical and warning min are invalid")
		}
	}

	if c.WarningMax != nil && c.CriticalMax != nil {
		var wMax, cMax big.Float
		_, _, err := wMax.Parse(fmt.Sprint(c.WarningMax), 10)
		if err != nil {
			return errors.Wrap(err, "can't parse warning min")
		}
		_, _, err = cMax.Parse(fmt.Sprint(c.CriticalMax), 10)
		if err != nil {
			return errors.Wrap(err, "can't parse critical min")
		}

		if res := cMax.Cmp(&wMax); res == -1 {
			return errors.New("critical and warning max are invalid")
		}
	}

	return nil
}

// HasWarning checks if a warning threshold is set
func (c *Thresholds) HasWarning() bool {
	return c.WarningMax != nil || c.WarningMin != nil
}

// HasCritical checks if a critical threshold is set
func (c *Thresholds) HasCritical() bool {
	return c.CriticalMax != nil || c.CriticalMin != nil
}

// IsEmpty checks if the thresholds are empty
func (c *Thresholds) IsEmpty() bool {
	return c.WarningMin == nil && c.WarningMax == nil && c.CriticalMin == nil && c.CriticalMax == nil
}

// CheckValue checks if the input is violating the thresholds
func (c *Thresholds) CheckValue(v interface{}) (int, error) {
	var value, wMin, wMax, cMin, cMax big.Float
	_, _, err := value.Parse(fmt.Sprint(v), 10)
	if err != nil {
		return 0, errors.Wrap(err, "value can't be parsed")
	}
	if c.CriticalMin != nil {
		_, _, err := cMin.Parse(fmt.Sprint(c.CriticalMin), 10)
		if err != nil {
			return 0, errors.Wrap(err, "critical min can't be parsed")
		}
		if cMin.Cmp(&value) == 1 {
			return CRITICAL, nil
		}
	}
	if c.CriticalMax != nil {
		_, _, err := cMax.Parse(fmt.Sprint(c.CriticalMax), 10)
		if err != nil {
			return 0, errors.Wrap(err, "critical max can't be parsed")
		}
		if cMax.Cmp(&value) == -1 {
			return CRITICAL, nil
		}
	}
	if c.WarningMin != nil {
		_, _, err := wMin.Parse(fmt.Sprint(c.WarningMin), 10)
		if err != nil {
			return 0, errors.Wrap(err, "warning min can't be parsed")
		}
		if wMin.Cmp(&value) == 1 {
			return WARNING, nil
		}
	}
	if c.WarningMax != nil {
		_, _, err := wMax.Parse(fmt.Sprint(c.WarningMax), 10)
		if err != nil {
			return 0, errors.Wrap(err, "warning max can't be parsed")
		}
		if wMax.Cmp(&value) == -1 {
			return WARNING, nil
		}
	}
	return OK, nil
}

func (c *Thresholds) getWarning() string {
	return getRange(c.WarningMin, c.WarningMax)
}

func (c *Thresholds) getCritical() string {
	return getRange(c.CriticalMin, c.CriticalMax)
}

func getRange(min, max interface{}) string {
	if min == nil && max == nil {
		return ""
	}

	var res string

	if min != nil {
		var minString string
		switch m := min.(type) {
		case float64:
			minString = strconv.FormatFloat(m, 'f', -1, 64)
		default:
			minString = fmt.Sprint(m)
		}
		if minString != "0" || max == nil {
			res += minString + ":"
		}
	} else {
		res += "~:"
	}

	if max != nil {
		var maxString string
		switch m := max.(type) {
		case float64:
			maxString = strconv.FormatFloat(m, 'f', -1, 64)
		default:
			maxString = fmt.Sprint(m)
		}
		res += maxString
	}

	return res
}