moira

1
package handler
2

3
import (
4
	"fmt"
5
	"net/http"
6
	"strconv"
7

8
	"github.com/go-chi/chi"
9
	"github.com/go-chi/render"
10

11
	"go.avito.ru/DO/moira/api"
12
	"go.avito.ru/DO/moira/api/controller"
13
	"go.avito.ru/DO/moira/api/dto"
14
	"go.avito.ru/DO/moira/api/middleware"
15
	"go.avito.ru/DO/moira/expression"
16
	"go.avito.ru/DO/moira/logging"
17
	"go.avito.ru/DO/moira/target"
18
)
19

20
func triggers(router chi.Router) {
21
	router.Get("/", getAllTriggers)
22
	router.Put("/", createTrigger)
23
	router.With(middleware.Paginate(0, 10)).Get("/page", getTriggersPage)
24
	router.Route("/{triggerId}", trigger)
25
}
26

27
func getAllTriggers(writer http.ResponseWriter, request *http.Request) {
28
	triggersList, errorResponse := controller.GetAllTriggers(database)
29
	if errorResponse != nil {
30
		render.Render(writer, request, errorResponse)
31
		return
32
	}
33

34
	if err := render.Render(writer, request, triggersList); err != nil {
35
		render.Render(writer, request, api.ErrorRender(err))
36
		return
37
	}
38
}
39

40
func createTrigger(writer http.ResponseWriter, request *http.Request) {
41
	trigger := &dto.Trigger{}
42
	if err := render.Bind(request, trigger); err != nil {
43
		switch err.(type) {
44
		case target.ErrParseExpr, target.ErrEvalExpr, target.ErrUnknownFunction:
45
			_ = render.Render(writer, request, api.ErrorInvalidRequest(fmt.Errorf("Invalid graphite targets: %s", err.Error())))
46
		case expression.ErrInvalidExpression:
47
			_ = render.Render(writer, request, api.ErrorInvalidRequest(fmt.Errorf("Invalid expression: %s", err.Error())))
48
		default:
49
			_ = render.Render(writer, request, api.ErrorInternalServer(err))
50
		}
51
		return
52
	}
53

54
	timeSeriesNames := middleware.GetTimeSeriesNames(request)
55
	response, err := controller.CreateTrigger(database, triggerInheritanceDatabase, &trigger.TriggerModel, timeSeriesNames)
56
	if err != nil {
57
		_ = render.Render(writer, request, err)
58
		return
59
	}
60

61
	logging.GetLogger(trigger.ID).InfoE("Trigger created", map[string]interface{}{
62
		"login":      middleware.GetLogin(request),
63
		"trigger":    trigger,
64
		"user_agent": request.Header.Get("User-Agent"),
65
	})
66

67
	if err := render.Render(writer, request, response); err != nil {
68
		_ = render.Render(writer, request, api.ErrorRender(err))
69
		return
70
	}
71
}
72

73
func getTriggersPage(writer http.ResponseWriter, request *http.Request) {
74
	request.ParseForm()
75
	filterName := getTriggerName(request)
76
	filterTags := getRequestTags(request)
77
	onlyErrors := getOnlyProblemsFlag(request)
78

79
	page := middleware.GetPage(request)
80
	size := middleware.GetSize(request)
81

82
	triggersList, errorResponse := controller.GetTriggerPage(database, page, size, onlyErrors, filterTags, filterName)
83
	if errorResponse != nil {
84
		render.Render(writer, request, errorResponse)
85
		return
86
	}
87

88
	if err := render.Render(writer, request, triggersList); err != nil {
89
		render.Render(writer, request, api.ErrorRender(err))
90
		return
91
	}
92
}
93

94
func getOnlyProblemsFlag(request *http.Request) bool {
95
	onlyProblemsStr := request.FormValue("onlyProblems")
96
	if onlyProblemsStr != "" {
97
		onlyProblems, _ := strconv.ParseBool(onlyProblemsStr)
98
		return onlyProblems
99
	}
100
	return false
101
}
102

103
func getRequestTags(request *http.Request) []string {
104
	var filterTags []string
105
	i := 0
106
	for {
107
		tag := request.FormValue(fmt.Sprintf("tags[%v]", i))
108
		if tag == "" {
109
			break
110
		}
111
		filterTags = append(filterTags, tag)
112
		i++
113
	}
114
	return filterTags
115
}
116

117
func getTriggerName(request *http.Request) string {
118
	return request.FormValue("triggerName")
119
}
120