Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
package api
import (
"bytes"
"encoding/json"
"errors"
"io"
"net/http"
"reflect"
"strings"
)
var errAmbiguousAdminJSON = errors.New("request body must contain one unambiguous JSON object")
// decodeAdminJSONObject preserves the standard decoder's singleton aliases and
// unknown fields, but never chooses between competing values for a control.
// Callers supply small request structs (no embedded fields or custom decoders).
// Validate before unmarshalling so an invalid request cannot partially apply.
func decodeAdminJSONObject(w http.ResponseWriter, r *http.Request, dst any, limit int64) error {
_, err := decodeAdminJSONObjectData(w, r, dst, limit)
return err
}
// decodeAdminJSONObjectData also returns the validated document for callers
// that must distinguish omitted settings from deliberately supplied zero values.
func decodeAdminJSONObjectData(w http.ResponseWriter, r *http.Request, dst any, limit int64) ([]byte, error) {
if r.Body == nil {
return nil, errAmbiguousAdminJSON
}
r.Body = http.MaxBytesReader(w, r.Body, limit)
data, err := io.ReadAll(r.Body)
if err != nil {
return nil, err
}
data = bytes.TrimSpace(data)
if len(data) == 0 || data[0] != '{' || !json.Valid(data) {
return nil, errAmbiguousAdminJSON
}
if err := validateAdminJSONMembers(data, reflect.TypeOf(dst)); err != nil {
return nil, err
}
if err := json.Unmarshal(data, dst); err != nil {
return nil, err
}
return data, nil
}
func validateAdminJSONMembers(data []byte, target reflect.Type) error {
for target.Kind() == reflect.Pointer {
target = target.Elem()
}
data = bytes.TrimSpace(data)
switch target.Kind() {
case reflect.Struct, reflect.Map:
if data[0] != '{' {
return nil // The ordinary decoder reports incompatible field types.
}
decoder := json.NewDecoder(bytes.NewReader(data))
if _, err := decoder.Token(); err != nil {
return err
}
seen := make(map[string]bool)
for decoder.More() {
key, err := decoder.Token()
if err != nil {
return err
}
name := key.(string) // json.Valid already checked the object syntax.
canonical, child := adminJSONField(target, name)
if child != nil {
if seen[canonical] {
// Never echo names or values: map keys can be private group names.
return errAmbiguousAdminJSON
}
seen[canonical] = true
}
var value json.RawMessage
if err := decoder.Decode(&value); err != nil {
return err
}
if child != nil {
if err := validateAdminJSONMembers(value, child); err != nil {
return err
}
}
}
case reflect.Slice, reflect.Array:
if data[0] != '[' {
return nil
}
var values []json.RawMessage
if err := json.Unmarshal(data, &values); err != nil {
return err
}
for _, value := range values {
if err := validateAdminJSONMembers(value, target.Elem()); err != nil {
return err
}
}
}
return nil
}
func adminJSONField(target reflect.Type, name string) (string, reflect.Type) {
if target.Kind() == reflect.Map {
// Role/group names are data, not struct-field aliases. Distinct case is
// meaningful; only exact (including JSON-escaped) duplicates compete.
return name, target.Elem()
}
var foldedName string
var foldedType reflect.Type
for i := 0; i < target.NumField(); i++ {
field := target.Field(i)
if !field.IsExported() {
continue
}
key := strings.Split(field.Tag.Get("json"), ",")[0]
if key == "-" {
continue
}
if key == "" {
key = field.Name
}
if key == name {
return key, field.Type
}
if foldedType == nil && strings.EqualFold(key, name) {
foldedName, foldedType = key, field.Type
}
}
return foldedName, foldedType
}