opensensemap/osem_notify
1
0
Fork 0
Code Issues Pull requests Releases Activity

refactor healtcheck interface

Browse source 
now using first class functions for checkers, should be simpler to plug
functionality is the same
This commit is contained in:
noerw 2018-06-26 00:51:38 +02:00
parent bf853e0ff4
commit c80c760d41
5 changed files with 177 additions and 96 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
core/healthcheck_measurement_age.go Normal file
View file

@ -0,0 +1,36 @@
package core
import (
"fmt"
"time"
)
var checkMeasurementAge = checkType{
name: "measurement_age",
toString: func(r CheckResult) string {
return fmt.Sprintf("No measurement from %s (%s) since %s", r.TargetName, r.Target, r.Value)
},
checkFunc: func(e NotifyEvent, s Sensor, b Box) (CheckResult, error) {
result := CheckResult{
Event: e.Type,
Target: s.Id,
TargetName: s.Phenomenon,
Threshold: e.Threshold,
Value: s.LastMeasurement.Date.String(),
Status: CheckOk,
}
thresh, err := time.ParseDuration(e.Threshold)
if err != nil {
return CheckResult{}, err
}
if time.Since(s.LastMeasurement.Date) > thresh {
result.Status = CheckErr
}
result.Value = s.LastMeasurement.Date.String()
return result, nil
},
}

49
core/healthcheck_measurement_faulty.go Normal file
View file

@ -0,0 +1,49 @@
package core
import (
"fmt"
"strconv"
)
var checkMeasurementFaulty = checkType{
name: "measurement_faulty",
toString: func(r CheckResult) string {
return fmt.Sprintf("Sensor %s (%s) reads presumably faulty value of %s", r.TargetName, r.Target, r.Value)
},
checkFunc: func(e NotifyEvent, s Sensor, b Box) (CheckResult, error) {
result := CheckResult{
Event: e.Type,
Target: s.Id,
TargetName: s.Phenomenon,
Threshold: e.Threshold,
Value: s.LastMeasurement.Value,
Status: CheckOk,
}
val, err := strconv.ParseFloat(s.LastMeasurement.Value, 64)
if err != nil {
return result, err
}
if faultyVals[faultyValue{
sensor: s.Type,
val: val,
}] {
result.Status = CheckErr
}
return result, nil
},
}
type faultyValue struct {
sensor string
val float64
}
var faultyVals = map[faultyValue]bool{
faultyValue{sensor: "BMP280", val: 0.0}: true,
faultyValue{sensor: "HDC1008", val: 0.0}: true,
faultyValue{sensor: "HDC1008", val: -40}: true,
faultyValue{sensor: "SDS 011", val: 0.0}: true,
}

50
core/healthcheck_measurement_minmax.go Normal file
View file

@ -0,0 +1,50 @@
package core
import (
"fmt"
"strconv"
)
var checkMeasurementMin = checkType{
name: "measurement_min",
toString: func(r CheckResult) string {
return fmt.Sprintf("Sensor %s (%s) reads low value of %s", r.TargetName, r.Target, r.Value)
},
checkFunc: validateMeasurementMinMax,
}
var checkMeasurementMax = checkType{
name: "measurement_min",
toString: func(r CheckResult) string {
return fmt.Sprintf("Sensor %s (%s) reads high value of %s", r.TargetName, r.Target, r.Value)
},
checkFunc: validateMeasurementMinMax,
}
func validateMeasurementMinMax(e NotifyEvent, s Sensor, b Box) (CheckResult, error) {
result := CheckResult{
Event: e.Type,
Target: s.Id,
TargetName: s.Phenomenon,
Threshold: e.Threshold,
Value: s.LastMeasurement.Value,
Status: CheckOk,
}
thresh, err := strconv.ParseFloat(e.Threshold, 64)
if err != nil {
return result, err
}
val, err := strconv.ParseFloat(s.LastMeasurement.Value, 64)
if err != nil {
return result, err
}
if e.Type == eventMeasurementValMax && val > thresh ||
e.Type == eventMeasurementValMin && val < thresh {
result.Status = CheckErr
}
return result, nil
}

106
core/healthchecks.go
View file

@ -4,8 +4,8 @@ import (
"crypto/sha256"
"encoding/hex"
"fmt"
"strconv"
"time"
log "github.com/sirupsen/logrus"
)
const (
@ -18,33 +18,26 @@ const (
eventTargetAll = "all" // if event.Target is this value, all sensors will be checked
)
type checkType = struct{ description string }
var checkTypes = map[string]checkType{
eventMeasurementAge: checkType{"No measurement from %s (%s) since %s"},
eventMeasurementValMin: checkType{"Sensor %s (%s) reads low value of %s"},
eventMeasurementValMax: checkType{"Sensor %s (%s) reads high value of %s"},
eventMeasurementValFaulty: checkType{"Sensor %s (%s) reads presumably faulty value of %s"},
type checkType = struct {
name string // name that is used in config
toString func(result CheckResult) string // error message when check failed
checkFunc func(event NotifyEvent, sensor Sensor, context Box) (CheckResult, error)
}
type FaultyValue struct {
sensor string
val float64
}
var faultyVals = map[FaultyValue]bool{
FaultyValue{sensor: "BMP280", val: 0.0}: true,
FaultyValue{sensor: "HDC1008", val: 0.0}: true,
FaultyValue{sensor: "HDC1008", val: -40}: true,
FaultyValue{sensor: "SDS 011", val: 0.0}: true,
var checkers = map[string]checkType{
checkMeasurementAge.name: checkMeasurementAge,
checkMeasurementMin.name: checkMeasurementMin,
checkMeasurementMax.name: checkMeasurementMax,
checkMeasurementFaulty.name: checkMeasurementFaulty,
}
type CheckResult struct {
Status string
Event string
Target string
Status string // should be CheckOk | CheckErr
TargetName string
Value string
Target string
Event string // these should be copied from the NotifyEvent
Threshold string
}
@ -59,12 +52,13 @@ func (r CheckResult) String() string {
if r.Status == CheckOk {
return fmt.Sprintf("%s %s (on sensor %s (%s) with value %s)\n", r.Event, r.Status, r.TargetName, r.Target, r.Value)
} else {
return fmt.Sprintf("%s: "+checkTypes[r.Event].description+"\n", r.Status, r.TargetName, r.Target, r.Value)
return fmt.Sprintf("%s: %s"+"\n", r.Status, checkers[r.Event].toString(r))
}
}
func (box Box) RunChecks() ([]CheckResult, error) {
var results = []CheckResult{}
boxLogger := log.WithField("box", box.Id)
for _, event := range box.NotifyConf.Events {
for _, s := range box.Sensors {
@ -73,68 +67,18 @@ func (box Box) RunChecks() ([]CheckResult, error) {
continue
}
// a validator must set these values
var (
status = CheckOk
target = s.Id
targetName = s.Phenomenon
value string
)
checker := checkers[event.Type]
if checker.checkFunc == nil {
boxLogger.Warnf("ignoring unknown event type %s", event.Type)
continue
}
if event.Target == eventTargetAll || event.Target == s.Id {
switch event.Type {
case eventMeasurementAge:
thresh, err := time.ParseDuration(event.Threshold)
result, err := checker.checkFunc(event, s, box)
if err != nil {
return nil, err
}
if time.Since(s.LastMeasurement.Date) > thresh {
status = CheckErr
boxLogger.Errorf("error checking event %s", event.Type)
}
value = s.LastMeasurement.Date.String()
case eventMeasurementValMin, eventMeasurementValMax:
thresh, err := strconv.ParseFloat(event.Threshold, 64)
if err != nil {
return nil, err
}
val, err2 := strconv.ParseFloat(s.LastMeasurement.Value, 64)
if err2 != nil {
return nil, err2
}
if event.Type == eventMeasurementValMax && val > thresh ||
event.Type == eventMeasurementValMin && val < thresh {
status = CheckErr
}
value = s.LastMeasurement.Value
case eventMeasurementValFaulty:
val, err := strconv.ParseFloat(s.LastMeasurement.Value, 64)
if err != nil {
return nil, err
}
if faultyVals[FaultyValue{
sensor: s.Type,
val: val,
}] {
status = CheckErr
}
value = s.LastMeasurement.Value
}
results = append(results, CheckResult{
Threshold: event.Threshold,
Event: event.Type,
Target: target,
TargetName: targetName,
Value: value,
Status: status,
})
}
results = append(results, result)
}
}

12
core/osem_api.go
View file

@ -49,10 +49,7 @@ type NotifyConfig struct {
Events []NotifyEvent `json:"events"`
}
type Box struct {
Id string `json:"_id"`
Name string `json:"name"`
Sensors []struct {
type Sensor struct {
Id string `json:"_id"`
Phenomenon string `json:"title"`
Type string `json:"sensorType"`
@ -60,6 +57,11 @@ type Box struct {
Value string `json:"value"`
Date time.Time `json:"createdAt"`
} `json:"lastMeasurement"`
} `json:"sensors"`
}
type Box struct {
Id string `json:"_id"`
Name string `json:"name"`
Sensors []Sensor `json:"sensors"`
NotifyConf *NotifyConfig `json:"healthcheck"`
}