func (c *Check) Check() check.ExtensionCheckResult {
nodes, err := nodesInfo()
if err != nil {
return handler.Error(fmt.Sprintf("rabbitmq: %s", err.Error()))
}
warning := c.Warning
if os.Getenv(fmt.Sprintf("%s_WARNING", strings.ToUpper(c.Type))) != "" {
w, err := strconv.Atoi(
os.Getenv(fmt.Sprintf("%s_WARNING", strings.ToUpper(c.Type))),
)
if err != nil {
return handler.Error(fmt.Sprintf("%s warning: %s", c.Type, err.Error()))
}
warning = w
}
error, err := c.readErrorThreshold()
if err != nil {
return handler.Error(fmt.Sprintf("%s error: %s", c.Type, err.Error()))
}
nodeError := make(map[string]int)
nodeWarning := make(map[string]int)
for _, node := range nodes {
if !node.IsRunning {
continue
}
if c.Comp(c.Method(node), error) {
nodeError[node.Name] = c.Method(node)
continue
}
if c.Comp(c.Method(node), warning) {
nodeWarning[node.Name] = c.Method(node)
continue
}
}
if len(nodeError) > 0 {
return handler.Error(buildMessage(nodeError, nodeWarning))
} else if len(nodeWarning) > 0 {
return handler.Warning(buildMessage(nodeError, nodeWarning))
}
return handler.Ok("Every node are ok")
}
func UnitsStatesCheck() check.ExtensionCheckResult {
cl, err := NewFleetClient()
if err != nil {
return handler.Error(err.Error())
}
units, err := cl.UnitStates()
if err != nil {
return handler.Error(err.Error())
}
blackListRegexp := DefaultBlacklist
if v := os.Getenv("BLACKLIST_REGEXP"); v != "" {
blackListRegexp = v
}
reg, err := regexp.Compile(blackListRegexp)
if err != nil {
return handler.Error(err.Error())
}
wrongStates := []string{}
for _, u := range units {
if reg.MatchString(u.Name) {
continue
}
if u.SystemdActiveState == "failed" ||
u.SystemdActiveState == "inactive" ||
u.SystemdSubState == "dead" ||
u.SystemdSubState == "failed" {
wrongStates = append(wrongStates, u.Name)
}
}
if len(wrongStates) == 0 {
return handler.Ok("Every units are up and running")
} else {
return handler.Warning(
fmt.Sprintf(
"Failed units: %s",
strings.Join(wrongStates, ","),
),
)
}
}
func (c *StandardCheck) Check() check.ExtensionCheckResult {
v, err := c.Value()
if err != nil {
return handler.Error(err.Error())
}
if c.Comp(c.ErrorThreshold, v) {
return handler.Error(c.CheckMessage(v))
} else if c.Comp(c.WarningThreshold, v) {
return handler.Warning(c.CheckMessage(v))
} else {
return handler.Ok(c.CheckMessage(v))
}
}
func (c *Check) Check() check.ExtensionCheckResult {
value := 0.0
if v, err := c.fetchValue(); err != nil {
return handler.Error(fmt.Sprintf("%s: %s", c.Name, err.Error()))
} else {
value = v
}
message := fmt.Sprintf("%s: %s", c.Name, c.displayValue(value))
if value > c.errorThreshold {
return handler.Error(message)
} else if value > c.warningThreshold {
return handler.Warning(message)
}
return handler.Ok(message)
}
func UnitsCheck() check.ExtensionCheckResult {
cl, err := NewFleetClient()
if err != nil {
return handler.Error(err.Error())
}
units, err := cl.Units()
if err != nil {
return handler.Error(err.Error())
}
wrongStates := []string{}
for _, u := range units {
if u.DesiredState != u.CurrentState {
ju := job.Unit{Unit: *schema.MapSchemaUnitOptionsToUnitFile(u.Options)}
if !ju.IsGlobal() {
wrongStates = append(wrongStates, u.Name)
}
}
}
if len(wrongStates) == 0 {
return handler.Ok("Every untis are in their desired states")
} else {
return handler.Warning(
fmt.Sprintf(
"Units in an incoherent state: %s",
strings.Join(wrongStates, ","),
),
)
}
}