func TestGroupSets_ByAlert(t *testing.T) {
aks := map[string]string{
"a{host=a}": "a on a",
"a{host=b}": "a on b",
"a{host=c}": "a on c",
"a{host=d}": "a on d",
}
states := States{}
for a, sub := range aks {
ak, err := expr.ParseAlertKey(a)
if err != nil {
t.Fatal(err)
}
states[ak] = &State{Alert: ak.Name(), Group: ak.Group(), Subject: sub}
}
groups := states.GroupSets(5)
if len(groups) != 4 {
t.Fatalf("Expected 4 unique groups, but found %d.", len(groups))
}
groups = states.GroupSets(4)
if len(groups) != 1 {
t.Fatalf("Expected 1 unique group, but found %d.", len(groups))
}
}
func Action(t miniprofiler.Timer, w http.ResponseWriter, r *http.Request) (interface{}, error) {
var data struct {
Type string
User string
Message string
Keys []string
Notify bool
}
j := json.NewDecoder(r.Body)
if err := j.Decode(&data); err != nil {
return nil, err
}
var at sched.ActionType
switch data.Type {
case "ack":
at = sched.ActionAcknowledge
case "close":
at = sched.ActionClose
case "forget":
at = sched.ActionForget
}
errs := make(MultiError)
r.ParseForm()
successful := []expr.AlertKey{}
for _, key := range data.Keys {
ak, err := expr.ParseAlertKey(key)
if err != nil {
return nil, err
}
err = schedule.Action(data.User, data.Message, at, ak)
if err != nil {
errs[key] = err
} else {
successful = append(successful, ak)
}
}
if len(errs) != 0 {
return nil, errs
}
if data.Notify && len(successful) != 0 {
schedule.ActionNotify(at, data.User, data.Message, successful)
}
return nil, nil
}
func Status(t miniprofiler.Timer, w http.ResponseWriter, r *http.Request) (interface{}, error) {
r.ParseForm()
type ExtStatus struct {
AlertName string
*sched.State
}
m := make(map[string]ExtStatus)
for _, k := range r.Form["ak"] {
ak, err := expr.ParseAlertKey(k)
if err != nil {
return nil, err
}
st := ExtStatus{State: schedule.GetStatus(ak)}
if st.State == nil {
return nil, fmt.Errorf("unknown alert key: %v", k)
}
st.AlertName = ak.Name()
m[k] = st
}
return m, nil
}