1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
|
package interpreter
import ( "fmt" "regexp" "strconv" "strings" )
type AlertRule struct { expression IExpression }
func NewAlertRule(rule string) (*AlertRule, error) { exp, err := NewAndExpression(rule) return &AlertRule{expression: exp}, err }
func (r AlertRule) Interpret(stats map[string]float64) bool { return r.expression.Interpret(stats) }
type IExpression interface { Interpret(stats map[string]float64) bool }
type GreaterExpression struct { key string value float64 }
func (g GreaterExpression) Interpret(stats map[string]float64) bool { v, ok := stats[g.key] if !ok { return false } return v > g.value }
func NewGreaterExpression(exp string) (*GreaterExpression, error) { data := regexp.MustCompile(`\s+`).Split(strings.TrimSpace(exp), -1) if len(data) != 3 || data[1] != ">" { return nil, fmt.Errorf("exp is invalid: %s", exp) }
val, err := strconv.ParseFloat(data[2], 10) if err != nil { return nil, fmt.Errorf("exp is invalid: %s", exp) }
return &GreaterExpression{ key: data[0], value: val, }, nil }
type LessExpression struct { key string value float64 }
func (g LessExpression) Interpret(stats map[string]float64) bool { v, ok := stats[g.key] if !ok { return false } return v < g.value }
func NewLessExpression(exp string) (*LessExpression, error) { data := regexp.MustCompile(`\s+`).Split(strings.TrimSpace(exp), -1) if len(data) != 3 || data[1] != "<" { return nil, fmt.Errorf("exp is invalid: %s", exp) }
val, err := strconv.ParseFloat(data[2], 10) if err != nil { return nil, fmt.Errorf("exp is invalid: %s", exp) }
return &LessExpression{ key: data[0], value: val, }, nil }
type AndExpression struct { expressions []IExpression }
func (e AndExpression) Interpret(stats map[string]float64) bool { for _, expression := range e.expressions { if !expression.Interpret(stats) { return false } } return true }
func NewAndExpression(exp string) (*AndExpression, error) { exps := strings.Split(exp, "&&") expressions := make([]IExpression, len(exps))
for i, e := range exps { var expression IExpression var err error
switch { case strings.Contains(e, ">"): expression, err = NewGreaterExpression(e) case strings.Contains(e, "<"): expression, err = NewLessExpression(e) default: err = fmt.Errorf("exp is invalid: %s", exp) }
if err != nil { return nil, err }
expressions[i] = expression }
return &AndExpression{expressions: expressions}, nil }
|