Debian Codegraph @

thresholds.go

raw
1 package monitoringplugin
2
3 import (
4 "fmt"
5 "github.com/pkg/errors"
6 "math/big"
7 "strconv"
8 )
9
10 // Thresholds contains all threshold values
11 type Thresholds struct {
12 WarningMin interface{} `json:"warningMin" xml:"warningMin"`
13 WarningMax interface{} `json:"warningMax" xml:"warningMax"`
14 CriticalMin interface{} `json:"criticalMin" xml:"criticalMin"`
15 CriticalMax interface{} `json:"criticalMax" xml:"criticalMax"`
16 }
17
18 // NewThresholds creates a new threshold
19 func NewThresholds(warningMin, warningMax, criticalMin, criticalMax interface{}) Thresholds {
20 return Thresholds{
21 WarningMin: warningMin,
22 WarningMax: warningMax,
23 CriticalMin: criticalMin,
24 CriticalMax: criticalMax,
25 }
26 }
27
28 // Validate checks if the Thresholds contains some invalid combination of warning and critical values
29 func (c *Thresholds) Validate() error {
30 if c.WarningMin != nil && c.WarningMax != nil {
31 var min, max big.Float
32 _, _, err := min.Parse(fmt.Sprint(c.WarningMin), 10)
33 if err != nil {
34 return errors.Wrap(err, "can't parse warning min")
35 }
36 _, _, err = max.Parse(fmt.Sprint(c.WarningMax), 10)
37 if err != nil {
38 return errors.Wrap(err, "can't parse warning max")
39 }
40
41 if res := min.Cmp(&max); res == 1 {
42 return errors.New("warning min and max are invalid")
43 }
44 }
45
46 if c.CriticalMin != nil && c.CriticalMax != nil {
47 var min, max big.Float
48 _, _, err := min.Parse(fmt.Sprint(c.CriticalMin), 10)
49 if err != nil {
50 return errors.Wrap(err, "can't parse critical min")
51 }
52 _, _, err = max.Parse(fmt.Sprint(c.CriticalMax), 10)
53 if err != nil {
54 return errors.Wrap(err, "can't parse critical max")
55 }
56
57 if res := min.Cmp(&max); res == 1 {
58 return errors.New("critical min and max are invalid")
59 }
60 }
61
62 if c.CriticalMin != nil && c.WarningMin != nil {
63 var wMin, cMin big.Float
64 _, _, err := wMin.Parse(fmt.Sprint(c.WarningMin), 10)
65 if err != nil {
66 return errors.Wrap(err, "can't parse warning min")
67 }
68 _, _, err = cMin.Parse(fmt.Sprint(c.CriticalMin), 10)
69 if err != nil {
70 return errors.Wrap(err, "can't parse critical min")
71 }
72
73 if res := cMin.Cmp(&wMin); res == 1 {
74 return errors.New("critical and warning min are invalid")
75 }
76 }
77
78 if c.WarningMax != nil && c.CriticalMax != nil {
79 var wMax, cMax big.Float
80 _, _, err := wMax.Parse(fmt.Sprint(c.WarningMax), 10)
81 if err != nil {
82 return errors.Wrap(err, "can't parse warning min")
83 }
84 _, _, err = cMax.Parse(fmt.Sprint(c.CriticalMax), 10)
85 if err != nil {
86 return errors.Wrap(err, "can't parse critical min")
87 }
88
89 if res := cMax.Cmp(&wMax); res == -1 {
90 return errors.New("critical and warning max are invalid")
91 }
92 }
93
94 return nil
95 }
96
97 // HasWarning checks if a warning threshold is set
98 func (c *Thresholds) HasWarning() bool {
99 return c.WarningMax != nil || c.WarningMin != nil
100 }
101
102 // HasCritical checks if a critical threshold is set
103 func (c *Thresholds) HasCritical() bool {
104 return c.CriticalMax != nil || c.CriticalMin != nil
105 }
106
107 // IsEmpty checks if the thresholds are empty
108 func (c *Thresholds) IsEmpty() bool {
109 return c.WarningMin == nil && c.WarningMax == nil && c.CriticalMin == nil && c.CriticalMax == nil
110 }
111
112 // CheckValue checks if the input is violating the thresholds
113 func (c *Thresholds) CheckValue(v interface{}) (int, error) {
114 var value, wMin, wMax, cMin, cMax big.Float
115 _, _, err := value.Parse(fmt.Sprint(v), 10)
116 if err != nil {
117 return 0, errors.Wrap(err, "value can't be parsed")
118 }
119 if c.CriticalMin != nil {
120 _, _, err := cMin.Parse(fmt.Sprint(c.CriticalMin), 10)
121 if err != nil {
122 return 0, errors.Wrap(err, "critical min can't be parsed")
123 }
124 if cMin.Cmp(&value) == 1 {
125 return CRITICAL, nil
126 }
127 }
128 if c.CriticalMax != nil {
129 _, _, err := cMax.Parse(fmt.Sprint(c.CriticalMax), 10)
130 if err != nil {
131 return 0, errors.Wrap(err, "critical max can't be parsed")
132 }
133 if cMax.Cmp(&value) == -1 {
134 return CRITICAL, nil
135 }
136 }
137 if c.WarningMin != nil {
138 _, _, err := wMin.Parse(fmt.Sprint(c.WarningMin), 10)
139 if err != nil {
140 return 0, errors.Wrap(err, "warning min can't be parsed")
141 }
142 if wMin.Cmp(&value) == 1 {
143 return WARNING, nil
144 }
145 }
146 if c.WarningMax != nil {
147 _, _, err := wMax.Parse(fmt.Sprint(c.WarningMax), 10)
148 if err != nil {
149 return 0, errors.Wrap(err, "warning max can't be parsed")
150 }
151 if wMax.Cmp(&value) == -1 {
152 return WARNING, nil
153 }
154 }
155 return OK, nil
156 }
157
158 func (c *Thresholds) getWarning() string {
159 return getRange(c.WarningMin, c.WarningMax)
160 }
161
162 func (c *Thresholds) getCritical() string {
163 return getRange(c.CriticalMin, c.CriticalMax)
164 }
165
166 func getRange(min, max interface{}) string {
167 if min == nil && max == nil {
168 return ""
169 }
170
171 var res string
172
173 if min != nil {
174 var minString string
175 switch m := min.(type) {
176 case float64:
177 minString = strconv.FormatFloat(m, 'f', -1, 64)
178 default:
179 minString = fmt.Sprint(m)
180 }
181 if minString != "0" || max == nil {
182 res += minString + ":"
183 }
184 } else {
185 res += "~:"
186 }
187
188 if max != nil {
189 var maxString string
190 switch m := max.(type) {
191 case float64:
192 maxString = strconv.FormatFloat(m, 'f', -1, 64)
193 default:
194 maxString = fmt.Sprint(m)
195 }
196 res += maxString
197 }
198
199 return res
200 }