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 := models.ParseAlertKey(a)
if err != nil {
t.Fatal(err)
}
states[ak] = &models.IncidentState{AlertKey: models.AlertKey(a), Alert: ak.Name(), Tags: ak.Group().Tags(), 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 TestGroupSets_AboveAndBelow(t *testing.T) {
aks := map[string]string{
"a1{host=a}": "a1 on a",
"a2{host=a}": "a2 on a",
"a3{host=a}": "a3 on a",
"a4{host=a}": "a4 on a",
}
states := States{}
for a, sub := range aks {
ak, err := models.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 models.ActionType
switch data.Type {
case "ack":
at = models.ActionAcknowledge
case "close":
at = models.ActionClose
case "forget":
at = models.ActionForget
}
errs := make(MultiError)
r.ParseForm()
successful := []models.AlertKey{}
for _, key := range data.Keys {
ak, err := models.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 {
err := schedule.ActionNotify(at, data.User, data.Message, successful)
if err != nil {
return nil, err
}
}
return nil, nil
}
func Status(t miniprofiler.Timer, w http.ResponseWriter, r *http.Request) (interface{}, error) {
r.ParseForm()
type ExtStatus struct {
AlertName string
*models.IncidentState
}
m := make(map[string]ExtStatus)
for _, k := range r.Form["ak"] {
ak, err := models.ParseAlertKey(k)
if err != nil {
return nil, err
}
var state *models.IncidentState
if r.FormValue("all") != "" {
allInc, err := schedule.DataAccess.State().GetAllIncidents(ak)
if err != nil {
return nil, err
}
if len(allInc) == 0 {
return nil, fmt.Errorf("No incidents for alert key")
}
state = allInc[0]
allEvents := models.EventsByTime{}
for _, inc := range allInc {
for _, e := range inc.Events {
allEvents = append(allEvents, e)
}
}
sort.Sort(allEvents)
state.Events = allEvents
} else {
state, err = schedule.DataAccess.State().GetLatestIncident(ak)
if err != nil {
return nil, err
}
}
st := ExtStatus{IncidentState: state}
if st.IncidentState == nil {
return nil, fmt.Errorf("unknown alert key: %v", k)
}
st.AlertName = ak.Name()
m[k] = st
}
return m, 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 := models.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
}
