mirror of
https://github.com/openziti/zrok.git
synced 2025-01-31 10:31:48 +01:00
108 lines
3.7 KiB
Go
108 lines
3.7 KiB
Go
package controller
|
|
|
|
import (
|
|
"github.com/go-openapi/runtime/middleware"
|
|
"github.com/openziti/zrok/controller/store"
|
|
"github.com/openziti/zrok/rest_model_zrok"
|
|
"github.com/openziti/zrok/rest_server_zrok/operations/metadata"
|
|
"github.com/sirupsen/logrus"
|
|
"slices"
|
|
)
|
|
|
|
type sparklinesHandler struct {
|
|
}
|
|
|
|
func newSparklinesHandler() *sparklinesHandler {
|
|
return &sparklinesHandler{}
|
|
}
|
|
|
|
func (h *sparklinesHandler) Handle(params metadata.GetSparklinesParams, principal *rest_model_zrok.Principal) middleware.Responder {
|
|
trx, err := str.Begin()
|
|
if err != nil {
|
|
logrus.Errorf("error beginning transaction: %v", err)
|
|
return metadata.NewGetSparklinesInternalServerError()
|
|
}
|
|
defer func() { _ = trx.Rollback() }()
|
|
|
|
out := &metadata.GetSparklinesOKBody{}
|
|
|
|
if len(params.Body.Environments) > 0 {
|
|
if envs, err := str.FindEnvironmentsForAccount(int(principal.ID), trx); err == nil {
|
|
var selectedEnvs []*store.Environment
|
|
selectedEnvsIdIdx := make(map[int]*store.Environment)
|
|
for _, envZId := range params.Body.Environments {
|
|
if idx := slices.IndexFunc(envs, func(env *store.Environment) bool { return env.ZId == envZId }); idx > -1 {
|
|
selectedEnvs = append(selectedEnvs, envs[idx])
|
|
selectedEnvsIdIdx[envs[idx].Id] = envs[idx]
|
|
} else {
|
|
logrus.Warnf("requested sparkdata for environment '%v' not owned by '%v'", envZId, principal.Email)
|
|
}
|
|
}
|
|
envsRxSparkdata, envsTxSparkdata, err := sparkDataForEnvironments(selectedEnvs)
|
|
if err != nil {
|
|
logrus.Errorf("error getting sparkdata for selected environments for '%v': %v", principal.Email, err)
|
|
return metadata.NewGetSparklinesInternalServerError()
|
|
}
|
|
for envId, rx := range envsRxSparkdata {
|
|
tx := envsTxSparkdata[envId]
|
|
forEnv := selectedEnvsIdIdx[envId]
|
|
|
|
var samples []*rest_model_zrok.MetricsSample
|
|
for i := 0; i < len(rx) && i < len(tx); i++ {
|
|
samples = append(samples, &rest_model_zrok.MetricsSample{
|
|
Rx: float64(rx[i]),
|
|
Tx: float64(tx[i]),
|
|
})
|
|
}
|
|
out.Sparklines = append(out.Sparklines, &rest_model_zrok.Metrics{
|
|
Scope: "environment",
|
|
ID: forEnv.ZId,
|
|
Samples: samples,
|
|
})
|
|
}
|
|
} else {
|
|
logrus.Errorf("error finding environments for '%v': %v", principal.Email, err)
|
|
return metadata.NewGetSparklinesInternalServerError()
|
|
}
|
|
}
|
|
|
|
if len(params.Body.Shares) > 0 {
|
|
if shrs, err := str.FindAllSharesForAccount(int(principal.ID), trx); err == nil {
|
|
var selectedShares []*store.Share
|
|
for _, selectedShareToken := range params.Body.Shares {
|
|
if idx := slices.IndexFunc(shrs, func(shr *store.Share) bool { return shr.Token == selectedShareToken }); idx > -1 {
|
|
selectedShares = append(selectedShares, shrs[idx])
|
|
} else {
|
|
logrus.Warnf("requested sparkdata for share '%v' not owned by '%v'", selectedShareToken, principal.Email)
|
|
}
|
|
}
|
|
shrsRxSparkdata, shrsTxSparkdata, err := sparkDataForShares(selectedShares)
|
|
if err != nil {
|
|
logrus.Errorf("error getting sparkdata for selected shares for '%v': %v", principal.Email, err)
|
|
return metadata.NewGetSparklinesInternalServerError()
|
|
}
|
|
for shrToken, rx := range shrsRxSparkdata {
|
|
tx := shrsTxSparkdata[shrToken]
|
|
|
|
var samples []*rest_model_zrok.MetricsSample
|
|
for i := 0; i < len(rx) && i < len(tx); i++ {
|
|
samples = append(samples, &rest_model_zrok.MetricsSample{
|
|
Rx: float64(rx[i]),
|
|
Tx: float64(tx[i]),
|
|
})
|
|
}
|
|
out.Sparklines = append(out.Sparklines, &rest_model_zrok.Metrics{
|
|
Scope: "share",
|
|
ID: shrToken,
|
|
Samples: samples,
|
|
})
|
|
}
|
|
} else {
|
|
logrus.Errorf("error finding shares for '%v': %v", principal.Email, err)
|
|
return metadata.NewGetSparklinesInternalServerError()
|
|
}
|
|
}
|
|
|
|
return metadata.NewGetSparklinesOK().WithPayload(out)
|
|
}
|