statping/handlers/services.go

320 lines
7.9 KiB
Go
Raw Normal View History

2018-12-04 05:57:11 +00:00
// Statping
2018-08-16 06:22:20 +00:00
// Copyright (C) 2018. Hunter Long and the project contributors
// Written by Hunter Long <info@socialeck.com> and the project contributors
//
2018-12-04 04:17:29 +00:00
// https://github.com/hunterlong/statping
2018-08-16 06:22:20 +00:00
//
// The licenses for most software and other practical works are designed
// to take away your freedom to share and change the works. By contrast,
// the GNU General Public License is intended to guarantee your freedom to
// share and change all versions of a program--to make sure it remains free
// software for all its users.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
2018-06-30 00:57:05 +00:00
package handlers
import (
"encoding/json"
"errors"
"fmt"
2018-06-30 00:57:05 +00:00
"github.com/gorilla/mux"
2018-12-04 04:17:29 +00:00
"github.com/hunterlong/statping/core"
2020-02-24 05:53:15 +00:00
"github.com/hunterlong/statping/database"
2018-12-04 04:17:29 +00:00
"github.com/hunterlong/statping/types"
"github.com/hunterlong/statping/utils"
2018-06-30 00:57:05 +00:00
"net/http"
2018-09-18 22:02:27 +00:00
"time"
2018-06-30 00:57:05 +00:00
)
func renderServiceChartsHandler(w http.ResponseWriter, r *http.Request) {
services := core.CoreApp.Services
2018-07-04 09:00:16 +00:00
w.Header().Set("Content-Type", "text/javascript")
w.Header().Set("Cache-Control", "max-age=60")
2018-09-18 22:02:27 +00:00
end := utils.Now().UTC()
start := utils.Now().Add((-24 * 7) * time.Hour).UTC()
var srvs []*core.Service
2018-09-18 22:02:27 +00:00
for _, s := range services {
srvs = append(srvs, s.(*core.Service))
2018-09-18 22:02:27 +00:00
}
out := struct {
Services []*core.Service
2018-10-03 15:20:45 +00:00
Start int64
End int64
}{srvs, start.Unix(), end.Unix()}
2018-09-18 22:02:27 +00:00
executeJSResponse(w, r, "charts.js", out)
2018-07-04 01:19:18 +00:00
}
func servicesHandler(w http.ResponseWriter, r *http.Request) {
2018-12-31 11:41:19 +00:00
data := map[string]interface{}{
"Services": core.CoreApp.Services,
}
ExecuteResponse(w, r, "services.gohtml", data, nil)
2018-06-30 00:57:05 +00:00
}
type serviceOrder struct {
Id int64 `json:"service"`
Order int `json:"order"`
}
func reorderServiceHandler(w http.ResponseWriter, r *http.Request) {
2018-11-29 16:26:42 +00:00
r.ParseForm()
var newOrder []*serviceOrder
decoder := json.NewDecoder(r.Body)
2018-11-29 16:26:42 +00:00
decoder.Decode(&newOrder)
for _, s := range newOrder {
service := core.SelectService(s.Id)
service.Order = s.Order
2018-11-29 16:26:42 +00:00
service.Update(false)
}
returnJson(newOrder, w, r)
}
2020-01-20 05:02:15 +00:00
func apiServiceHandler(r *http.Request) interface{} {
2018-06-30 00:57:05 +00:00
vars := mux.Vars(r)
2018-12-06 19:03:55 +00:00
servicer := core.SelectService(utils.ToInt(vars["id"]))
if servicer == nil {
2020-01-20 05:02:15 +00:00
return errors.New("service not found")
}
2020-01-20 05:02:15 +00:00
return *servicer.Select()
2018-06-30 00:57:05 +00:00
}
func apiCreateServiceHandler(w http.ResponseWriter, r *http.Request) {
var service *types.Service
decoder := json.NewDecoder(r.Body)
err := decoder.Decode(&service)
if err != nil {
sendErrorJson(err, w, r)
return
}
newService := core.ReturnService(service)
_, err = newService.Create(true)
if err != nil {
sendErrorJson(err, w, r)
return
}
sendJsonAction(newService, "create", w, r)
}
2020-01-30 04:34:47 +00:00
func apiTestServiceHandler(w http.ResponseWriter, r *http.Request) {
var service *types.Service
decoder := json.NewDecoder(r.Body)
err := decoder.Decode(&service)
if err != nil {
sendErrorJson(err, w, r)
return
}
newService := core.ReturnService(service)
_, err = newService.Create(true)
if err != nil {
sendErrorJson(err, w, r)
return
}
sendJsonAction(newService, "create", w, r)
}
func apiServiceUpdateHandler(w http.ResponseWriter, r *http.Request) {
2018-06-30 00:57:05 +00:00
vars := mux.Vars(r)
2018-12-06 19:03:55 +00:00
service := core.SelectService(utils.ToInt(vars["id"]))
if service == nil {
sendErrorJson(errors.New("service not found"), w, r)
return
}
decoder := json.NewDecoder(r.Body)
decoder.Decode(&service)
err := service.Update(true)
if err != nil {
sendErrorJson(err, w, r)
return
}
go service.Check(true)
sendJsonAction(service, "update", w, r)
2018-10-07 22:38:56 +00:00
}
2018-10-06 03:35:53 +00:00
func apiServiceRunningHandler(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
service := core.SelectService(utils.ToInt(vars["id"]))
if service == nil {
sendErrorJson(errors.New("service not found"), w, r)
return
}
if service.IsRunning() {
service.Close()
} else {
service.Start()
}
sendJsonAction(service, "running", w, r)
}
2020-02-24 16:26:01 +00:00
func apiServiceDataHandler(w Responder, r *http.Request) {
vars := mux.Vars(r)
2020-02-24 05:53:15 +00:00
service, err := database.Service(utils.ToInt(vars["id"]))
if err != nil {
sendErrorJson(errors.New("service data not found"), w, r)
return
}
2020-02-24 16:26:01 +00:00
groupQuery := database.ParseQueries(r, service.Hits().DB)
2020-02-24 05:53:15 +00:00
obj := core.GraphData(groupQuery, &types.Hit{}, database.ByAverage("latency"))
2020-02-21 05:36:23 +00:00
returnJson(obj, w, r)
}
func apiServiceFailureDataHandler(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
2020-02-24 05:53:15 +00:00
service, err := database.Service(utils.ToInt(vars["id"]))
if err != nil {
2020-02-21 05:36:23 +00:00
sendErrorJson(errors.New("service data not found"), w, r)
return
}
2020-02-24 16:26:01 +00:00
groupQuery := database.ParseQueries(r, service.Hits().DB)
2020-02-22 04:40:05 +00:00
2020-02-24 05:53:15 +00:00
obj := core.GraphData(groupQuery, &types.Failure{}, database.ByCount)
2020-02-22 04:40:05 +00:00
returnJson(obj, w, r)
}
func apiServicePingDataHandler(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
2020-02-24 05:53:15 +00:00
service, err := database.Service(utils.ToInt(vars["id"]))
if err != nil {
sendErrorJson(errors.New("service data not found"), w, r)
return
}
2020-02-24 16:26:01 +00:00
groupQuery := database.ParseQueries(r, service.Hits().DB)
2020-02-24 05:53:15 +00:00
obj := core.GraphData(groupQuery, &types.Hit{}, database.ByAverage("ping_time"))
returnJson(obj, w, r)
}
2019-01-29 12:02:13 +00:00
type dataXy struct {
X int `json:"x"`
Y int `json:"y"`
}
type dataXyMonth struct {
Date string `json:"date"`
2019-01-29 12:02:13 +00:00
Data []*dataXy `json:"data"`
}
func apiServiceHeatmapHandler(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
service := core.SelectService(utils.ToInt(vars["id"]))
if service == nil {
sendErrorJson(errors.New("service data not found"), w, r)
return
}
var monthOutput []*dataXyMonth
start := service.CreatedAt
//now := utils.Now()
2019-01-29 12:02:13 +00:00
sY, sM, _ := start.Date()
var date time.Time
month := int(sM)
maxMonth := 12
for year := int(sY); year <= utils.Now().Year(); year++ {
2019-01-29 12:02:13 +00:00
if year == utils.Now().Year() {
maxMonth = int(utils.Now().Month())
}
2019-01-29 12:02:13 +00:00
for m := month; m <= maxMonth; m++ {
2019-01-29 12:02:13 +00:00
var output []*dataXy
for day := 1; day <= 31; day++ {
date = time.Date(year, time.Month(m), day, 0, 0, 0, 0, time.UTC)
2019-01-29 12:02:13 +00:00
failures, _ := service.TotalFailuresOnDate(date)
output = append(output, &dataXy{day, int(failures)})
}
thisDate := fmt.Sprintf("%v-%v-01 00:00:00", year, m)
monthOutput = append(monthOutput, &dataXyMonth{thisDate, output})
2019-01-29 12:02:13 +00:00
}
month = 1
2019-01-29 12:02:13 +00:00
}
returnJson(monthOutput, w, r)
2019-01-29 12:02:13 +00:00
}
func apiServiceDeleteHandler(w http.ResponseWriter, r *http.Request) {
2018-10-07 22:38:56 +00:00
vars := mux.Vars(r)
service := core.SelectService(utils.ToInt(vars["id"]))
if service == nil {
sendErrorJson(errors.New("service not found"), w, r)
return
}
err := service.Delete()
if err != nil {
sendErrorJson(err, w, r)
return
}
sendJsonAction(service, "delete", w, r)
2018-10-03 10:47:32 +00:00
}
2020-01-20 05:02:15 +00:00
func apiAllServicesHandler(r *http.Request) interface{} {
services := core.Services()
2020-01-20 05:02:15 +00:00
return joinServices(services)
}
2020-01-20 05:02:15 +00:00
func joinServices(srvs []types.ServiceInterface) []*types.Service {
var services []*types.Service
for _, v := range srvs {
2020-01-20 05:02:15 +00:00
services = append(services, v.Select())
}
return services
}
2020-02-24 16:26:01 +00:00
func servicesDeleteFailuresHandler(w Responder, r *http.Request) {
2018-10-03 10:47:32 +00:00
vars := mux.Vars(r)
service := core.SelectService(utils.ToInt(vars["id"]))
2019-02-12 19:38:36 +00:00
if service == nil {
sendErrorJson(errors.New("service not found"), w, r)
return
}
service.DeleteFailures()
2019-02-12 19:38:36 +00:00
sendJsonAction(service, "delete_failures", w, r)
2018-06-30 00:57:05 +00:00
}
2019-01-10 16:47:01 +00:00
2020-01-20 05:02:15 +00:00
func apiServiceFailuresHandler(r *http.Request) interface{} {
2019-01-10 16:47:01 +00:00
vars := mux.Vars(r)
2020-02-24 05:53:15 +00:00
service, err := database.Service(utils.ToInt(vars["id"]))
if err != nil {
2020-01-20 05:02:15 +00:00
return errors.New("service not found")
2019-01-10 16:47:01 +00:00
}
2020-02-24 05:53:15 +00:00
2020-02-24 16:26:01 +00:00
service.Hits()
service.Failures()
2020-02-24 05:53:15 +00:00
var fails []types.Failure
2020-02-24 16:26:01 +00:00
service.Failures().DB.Requests(r).Find(&fails)
2020-01-26 21:01:43 +00:00
return fails
2019-01-10 16:47:01 +00:00
}
2020-01-20 05:02:15 +00:00
func apiServiceHitsHandler(r *http.Request) interface{} {
2019-01-10 16:47:01 +00:00
vars := mux.Vars(r)
2020-02-24 05:53:15 +00:00
service, err := database.Service(utils.ToInt(vars["id"]))
2019-01-10 16:47:01 +00:00
if err != nil {
2020-02-24 05:53:15 +00:00
return errors.New("service not found")
2019-01-10 16:47:01 +00:00
}
2020-02-24 05:53:15 +00:00
var hits []types.Hit
service.Hits().Find(&hits)
2020-01-20 05:02:15 +00:00
return hits
2019-01-10 16:47:01 +00:00
}
2019-12-18 11:36:29 +00:00
func createServiceHandler(w http.ResponseWriter, r *http.Request) {
ExecuteResponse(w, r, "service_create.gohtml", core.CoreApp, nil)
}