35b7308ce2
Backend: - Audit-Log: Search-Endpoint mit ILIKE-Filter (actor/action/subject/date) - NTP: /ntp/status via chronyc tracking (Stratum, Offset, Quelle) - System: /service-restart mit Allowlist (haproxy/squid/unbound/chrony/scheduler) - Domain-Response-Headers + Rate-Limit (Migration 0024) - Join-Tokens (Migration 0025), Cluster-mTLS, Aggregator-Fan-Out - apt-Service für Update-Banner (apt-get update + Versionsprüfung) - Backup-Retry mit exponential backoff (retry_apt 3×) - publish.sh fail-fast + cleanup-old.sh (max 10 Versionen) Frontend: - Audit-Log-Page (/audit) mit Filter + Pagination - ErrorBoundary an React-Root + Vite build-target festgenagelt (iOS 15+) - Storage-Schema-Stamp: auto-wipe bei Versions-Mismatch (blank-page-Fix) - EmptyState-Komponente überall ausgerollt - SSL: Aggregate-Karte (total/expiring/expired/errors) - Backups: Aggregate-Karte (letzter Backup/Größe/Fehlschläge 24h) + Backup-Now - NTP: Sync-Status-Karte (chronyc tracking live) - Domains: Backend-UP/DOWN-Chip aus HAProxy-Stats - Backends: HAProxy-Status-Spalte (UP/DEGRADED/DOWN) - Settings: Service-Neustart-Karte (haproxy/squid/unbound/chrony/scheduler) - Settings: Upgrade-Status-Card, Wartungsmodus, Auto-Update, Retention - Dashboard: Recent-Alerts, Cluster-Health, License-Chip, Onboarding-Hint - System-Regeln im Firewall als eigener Tab Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
298 lines
8.0 KiB
Go
298 lines
8.0 KiB
Go
package handlers
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"log/slog"
|
|
"strconv"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
|
|
"git.netcell-it.de/projekte/edgeguard-native/internal/handlers/response"
|
|
"git.netcell-it.de/projekte/edgeguard-native/internal/models"
|
|
"git.netcell-it.de/projekte/edgeguard-native/internal/services/audit"
|
|
"git.netcell-it.de/projekte/edgeguard-native/internal/services/domainheaders"
|
|
"git.netcell-it.de/projekte/edgeguard-native/internal/services/domains"
|
|
"git.netcell-it.de/projekte/edgeguard-native/internal/services/routingrules"
|
|
)
|
|
|
|
type DomainsHandler struct {
|
|
Repo *domains.Repo
|
|
Routing *routingrules.Repo
|
|
Headers *domainheaders.Repo
|
|
Audit *audit.Repo
|
|
NodeID string
|
|
|
|
// Reloader regenerates and applies the haproxy config. Symmetric
|
|
// to FirewallHandler.Reloader; called after every mutation so the
|
|
// running haproxy.cfg always matches the DB. Errors are logged
|
|
// but don't fail the API call (the row is committed and the
|
|
// operator can re-trigger via `edgeguard-ctl render-config`).
|
|
Reloader func(ctx context.Context) error
|
|
}
|
|
|
|
func NewDomainsHandler(repo *domains.Repo, routing *routingrules.Repo, headers *domainheaders.Repo, a *audit.Repo, nodeID string, reloader func(context.Context) error) *DomainsHandler {
|
|
return &DomainsHandler{Repo: repo, Routing: routing, Headers: headers, Audit: a, NodeID: nodeID, Reloader: reloader}
|
|
}
|
|
|
|
func (h *DomainsHandler) reload(ctx context.Context, op string) {
|
|
if h.Reloader == nil {
|
|
return
|
|
}
|
|
if err := h.Reloader(ctx); err != nil {
|
|
slog.Warn("haproxy: reload after domain mutation failed", "op", op, "error", err)
|
|
}
|
|
}
|
|
|
|
func (h *DomainsHandler) Register(rg *gin.RouterGroup) {
|
|
g := rg.Group("/domains")
|
|
g.GET("", h.List)
|
|
g.POST("", h.Create)
|
|
g.GET("/:id", h.Get)
|
|
g.PUT("/:id", h.Update)
|
|
g.DELETE("/:id", h.Delete)
|
|
g.GET("/:id/routing-rules", h.ListRoutingRules)
|
|
|
|
g.GET("/:id/headers", h.ListHeaders)
|
|
g.POST("/:id/headers", h.CreateHeader)
|
|
g.PUT("/:id/headers/:hid", h.UpdateHeader)
|
|
g.DELETE("/:id/headers/:hid", h.DeleteHeader)
|
|
}
|
|
|
|
func (h *DomainsHandler) List(c *gin.Context) {
|
|
out, err := h.Repo.List(c.Request.Context())
|
|
if err != nil {
|
|
response.Internal(c, err)
|
|
return
|
|
}
|
|
response.OK(c, gin.H{"domains": out})
|
|
}
|
|
|
|
func (h *DomainsHandler) Get(c *gin.Context) {
|
|
id, ok := parseID(c)
|
|
if !ok {
|
|
return
|
|
}
|
|
d, err := h.Repo.Get(c.Request.Context(), id)
|
|
if err != nil {
|
|
if errors.Is(err, domains.ErrNotFound) {
|
|
response.NotFound(c, err)
|
|
return
|
|
}
|
|
response.Internal(c, err)
|
|
return
|
|
}
|
|
response.OK(c, d)
|
|
}
|
|
|
|
func (h *DomainsHandler) Create(c *gin.Context) {
|
|
var req models.Domain
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.BadRequest(c, err)
|
|
return
|
|
}
|
|
out, err := h.Repo.Create(c.Request.Context(), req)
|
|
if err != nil {
|
|
response.Internal(c, err)
|
|
return
|
|
}
|
|
_ = h.Audit.Log(c.Request.Context(), actorOf(c), "domain.create", req.Name, out, h.NodeID)
|
|
response.Created(c, out); h.reload(c.Request.Context(), "create")
|
|
}
|
|
|
|
func (h *DomainsHandler) Update(c *gin.Context) {
|
|
id, ok := parseID(c)
|
|
if !ok {
|
|
return
|
|
}
|
|
var req models.Domain
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.BadRequest(c, err)
|
|
return
|
|
}
|
|
out, err := h.Repo.Update(c.Request.Context(), id, req)
|
|
if err != nil {
|
|
if errors.Is(err, domains.ErrNotFound) {
|
|
response.NotFound(c, err)
|
|
return
|
|
}
|
|
response.Internal(c, err)
|
|
return
|
|
}
|
|
_ = h.Audit.Log(c.Request.Context(), actorOf(c), "domain.update", out.Name, out, h.NodeID)
|
|
response.OK(c, out); h.reload(c.Request.Context(), "update")
|
|
}
|
|
|
|
func (h *DomainsHandler) Delete(c *gin.Context) {
|
|
id, ok := parseID(c)
|
|
if !ok {
|
|
return
|
|
}
|
|
if err := h.Repo.Delete(c.Request.Context(), id); err != nil {
|
|
if errors.Is(err, domains.ErrNotFound) {
|
|
response.NotFound(c, err)
|
|
return
|
|
}
|
|
response.Internal(c, err)
|
|
return
|
|
}
|
|
_ = h.Audit.Log(c.Request.Context(), actorOf(c), "domain.delete",
|
|
strconv.FormatInt(id, 10), gin.H{"id": id}, h.NodeID)
|
|
response.NoContent(c); h.reload(c.Request.Context(), "delete")
|
|
}
|
|
|
|
// ListRoutingRules narrows /routing-rules to one domain — UI uses this
|
|
// for the per-domain rules tab rather than fetching the global list
|
|
// and filtering client-side.
|
|
func (h *DomainsHandler) ListRoutingRules(c *gin.Context) {
|
|
id, ok := parseID(c)
|
|
if !ok {
|
|
return
|
|
}
|
|
out, err := h.Routing.ListForDomain(c.Request.Context(), id)
|
|
if err != nil {
|
|
response.Internal(c, err)
|
|
return
|
|
}
|
|
response.OK(c, gin.H{"routing_rules": out})
|
|
}
|
|
|
|
// parseID parses /:id as int64 and writes a 400 on parse failure.
|
|
// Returns (0, false) and aborts when the param is malformed.
|
|
func parseID(c *gin.Context) (int64, bool) {
|
|
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
|
|
if err != nil {
|
|
response.BadRequest(c, errors.New("invalid id"))
|
|
return 0, false
|
|
}
|
|
return id, true
|
|
}
|
|
|
|
// ── Response-Header CRUD ──────────────────────────────────────────────
|
|
//
|
|
// Header werden über `http-response set-header` von HAProxy gesetzt
|
|
// (siehe internal/haproxy/haproxy.cfg.tpl). Name ist case-insensitive
|
|
// unique pro Domain — Doppel-Eintrag erkennt PG selbst via Unique-Index
|
|
// und liefert 409 zurück.
|
|
|
|
func (h *DomainsHandler) ListHeaders(c *gin.Context) {
|
|
id, ok := parseID(c)
|
|
if !ok {
|
|
return
|
|
}
|
|
out, err := h.Headers.ListForDomain(c.Request.Context(), id)
|
|
if err != nil {
|
|
response.Internal(c, err)
|
|
return
|
|
}
|
|
response.OK(c, gin.H{"headers": out})
|
|
}
|
|
|
|
func (h *DomainsHandler) CreateHeader(c *gin.Context) {
|
|
id, ok := parseID(c)
|
|
if !ok {
|
|
return
|
|
}
|
|
var req models.DomainResponseHeader
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.BadRequest(c, err)
|
|
return
|
|
}
|
|
req.DomainID = id
|
|
if !validHeaderName(req.Name) {
|
|
response.BadRequest(c, errors.New("invalid header name"))
|
|
return
|
|
}
|
|
out, err := h.Headers.Create(c.Request.Context(), req)
|
|
if err != nil {
|
|
response.Internal(c, err)
|
|
return
|
|
}
|
|
_ = h.Audit.Log(c.Request.Context(), actorOf(c), "domain.header.create", out.Name, out, h.NodeID)
|
|
response.Created(c, out); h.reload(c.Request.Context(), "header.create")
|
|
}
|
|
|
|
func (h *DomainsHandler) UpdateHeader(c *gin.Context) {
|
|
_, ok := parseID(c)
|
|
if !ok {
|
|
return
|
|
}
|
|
hid, err := strconv.ParseInt(c.Param("hid"), 10, 64)
|
|
if err != nil {
|
|
response.BadRequest(c, errors.New("invalid header id"))
|
|
return
|
|
}
|
|
var req models.DomainResponseHeader
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.BadRequest(c, err)
|
|
return
|
|
}
|
|
if !validHeaderName(req.Name) {
|
|
response.BadRequest(c, errors.New("invalid header name"))
|
|
return
|
|
}
|
|
out, err := h.Headers.Update(c.Request.Context(), hid, req)
|
|
if err != nil {
|
|
if errors.Is(err, domainheaders.ErrNotFound) {
|
|
response.NotFound(c, err)
|
|
return
|
|
}
|
|
response.Internal(c, err)
|
|
return
|
|
}
|
|
_ = h.Audit.Log(c.Request.Context(), actorOf(c), "domain.header.update", out.Name, out, h.NodeID)
|
|
response.OK(c, out); h.reload(c.Request.Context(), "header.update")
|
|
}
|
|
|
|
func (h *DomainsHandler) DeleteHeader(c *gin.Context) {
|
|
_, ok := parseID(c)
|
|
if !ok {
|
|
return
|
|
}
|
|
hid, err := strconv.ParseInt(c.Param("hid"), 10, 64)
|
|
if err != nil {
|
|
response.BadRequest(c, errors.New("invalid header id"))
|
|
return
|
|
}
|
|
if err := h.Headers.Delete(c.Request.Context(), hid); err != nil {
|
|
if errors.Is(err, domainheaders.ErrNotFound) {
|
|
response.NotFound(c, err)
|
|
return
|
|
}
|
|
response.Internal(c, err)
|
|
return
|
|
}
|
|
_ = h.Audit.Log(c.Request.Context(), actorOf(c), "domain.header.delete",
|
|
strconv.FormatInt(hid, 10), gin.H{"id": hid}, h.NodeID)
|
|
response.NoContent(c); h.reload(c.Request.Context(), "header.delete")
|
|
}
|
|
|
|
// validHeaderName: RFC 7230 token chars. Wir engen das auf eine
|
|
// vernünftige Untermenge ein (a-z A-Z 0-9 + `-`), damit niemand
|
|
// versehentlich Newlines oder Quotes in den HAProxy-Renderer schiebt
|
|
// und die Config-Datei sprengt.
|
|
func validHeaderName(name string) bool {
|
|
if name == "" || len(name) > 100 {
|
|
return false
|
|
}
|
|
for _, r := range name {
|
|
switch {
|
|
case r >= 'a' && r <= 'z',
|
|
r >= 'A' && r <= 'Z',
|
|
r >= '0' && r <= '9',
|
|
r == '-':
|
|
// ok
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func actorOf(c *gin.Context) string {
|
|
if t := CurrentToken(c); t != nil {
|
|
return t.Actor
|
|
}
|
|
return "unknown"
|
|
}
|