Compare commits
8
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 sysops
|
d6e9412043 | ||
|
sysops
|
e6892535ed | ||
|
sysops
|
1c41b65a47 | ||
|
sysops
|
ec9bb27bb3 | ||
|
sysops
|
0fd9856b10 | ||
|
sysopsandClaude Sonnet 5
|
d447869246 | ||
|
sysopsandClaude Sonnet 5
|
b12d53f469 | ||
|
sysopsandClaude Sonnet 5
|
d63db93a4c |
@@ -1,4 +1,2 @@
|
||||
*.log
|
||||
.env
|
||||
web/*/node_modules/
|
||||
web/*/.next/
|
||||
|
||||
@@ -64,9 +64,6 @@ Keine Änderungen ermittelbar.
|
||||
## 2026-08-27 17:28 – 17:29 (1m)
|
||||
**Beschreibung:** Claude Code Session
|
||||
**Projekt:** code
|
||||
## 2026-08-28 21:44 – 21:44 (0m)
|
||||
**Beschreibung:** Claude Code Session
|
||||
**Projekt:** nexarch
|
||||
|
||||
### Commits
|
||||
Keine Commits in dieser Session.
|
||||
@@ -130,32 +127,5 @@ Keine Commits in dieser Session.
|
||||
- internal/config/config.go | 29 +++++++++++++++++++++++++++++
|
||||
- internal/db/db.go | 11 +++++++++++
|
||||
- migrations/0001_tenant_registry.sql | 10 ++++++++++
|
||||
- web/shl/README.md | 45 +++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/__tests__/Dialog.test.tsx | 38 ++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/__tests__/tokens.test.ts | 39 +++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/components/Dialog.tsx | 88 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/components/FormElements.tsx | 98 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/components/Shell.tsx | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/components/Table.tsx | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/components/Toast.tsx | 67 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/i18n/i18n.tsx | 75 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/index.ts | 25 +++++++++++++++++++++++++
|
||||
- web/shl/package.json | 23 +++++++++++++++++++++++
|
||||
- web/shl/theme/ThemeProvider.tsx | 81 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/tokens/tokens.ts | 96 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
- web/shl/tsconfig.json | 18 ++++++++++++++++++
|
||||
|
||||
---
|
||||
## 2026-08-28 21:51 – 21:57 (5m)
|
||||
**Beschreibung:** Claude Code Session
|
||||
**Projekt:** nexarch
|
||||
|
||||
### Commits
|
||||
- 3c226da SHL-01: fix — vitest jsdom-environment + jest-dom-Setup (3 Dialog-Tests schlugen ohne DOM fehl)
|
||||
|
||||
### Geänderte Dateien
|
||||
- web/shl/package.json | 2 ++
|
||||
- web/shl/vitest.config.ts | 8 ++++++++
|
||||
- web/shl/vitest.setup.ts | 1 +
|
||||
|
||||
---
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
// resync-api ist der Aufrufpunkt fuer API-11: startet den bereits
|
||||
// fertigen internal/resync.Handler (API-06) als eigenstaendigen
|
||||
// HTTP-Dienst. REINES WIRING — keine Aenderung an internal/resync/,
|
||||
// internal/audit/, internal/usage/ oder internal/moduleregistry/.
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/audit"
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/flag"
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/moduleregistry"
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/resync"
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/usage"
|
||||
)
|
||||
|
||||
// auditAdapter erfüllt resync.AuditRecorder über den bestehenden
|
||||
// audit.Log-Schreibpfad — kein neuer Audit-Code, nur Signatur-Anpassung
|
||||
// (audit.Log.Record nimmt ein Event-Struct, resync.AuditRecorder einzelne
|
||||
// Felder).
|
||||
type auditAdapter struct{ log *audit.Log }
|
||||
|
||||
func (a auditAdapter) Record(ctx context.Context, tenantSlug, actor, action, target string, metadata map[string]any, occurredAt time.Time) error {
|
||||
return a.log.Record(ctx, audit.Event{
|
||||
TenantSlug: tenantSlug, Actor: actor, Action: action, Target: target,
|
||||
Metadata: metadata, OccurredAt: occurredAt,
|
||||
})
|
||||
}
|
||||
|
||||
func main() {
|
||||
registryDSN := os.Getenv("NEXARCH_RESYNC_REGISTRY_DSN")
|
||||
if registryDSN == "" {
|
||||
log.Fatal("NEXARCH_RESYNC_REGISTRY_DSN muss gesetzt sein")
|
||||
}
|
||||
addr := os.Getenv("NEXARCH_RESYNC_API_LISTEN_ADDR")
|
||||
if addr == "" {
|
||||
addr = "127.0.0.1:8098"
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
pool, err := pgxpool.New(ctx, registryDSN)
|
||||
if err != nil {
|
||||
log.Fatalf("datenbankverbindung: %v", err)
|
||||
}
|
||||
defer pool.Close()
|
||||
|
||||
flagStore := flag.NewStore(pool)
|
||||
flagService := flag.NewService(flagStore, 30*time.Second)
|
||||
registry := moduleregistry.NewRegistry(pool, flagService)
|
||||
auditLog := audit.NewLog(pool)
|
||||
usageStore := usage.NewStore(pool)
|
||||
|
||||
handler := resync.NewHandler(registry, auditAdapter{log: auditLog}, usageStore)
|
||||
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/internal/resync/audit", handler.AuditHandler)
|
||||
mux.HandleFunc("/internal/resync/usage", handler.UsageHandler)
|
||||
mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
|
||||
|
||||
log.Printf("resync-api: listening on %s", addr)
|
||||
if err := http.ListenAndServe(addr, mux); err != nil {
|
||||
log.Fatalf("http server: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -1,66 +0,0 @@
|
||||
// statuspage-devserver stellt das OPS-02-Backend (internal/statuspage) fuer
|
||||
// die Next.js-Statusseite bereit und startet den periodischen Poller.
|
||||
// Getrennt von cmd/core aus demselben Grund wie die anderen *-devserver.
|
||||
package main
|
||||
|
||||
import (
|
||||
"context"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"strconv"
|
||||
"time"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/db"
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/statuspage"
|
||||
)
|
||||
|
||||
func main() {
|
||||
dsn := os.Getenv("NEXARCH_REGISTRY_DSN")
|
||||
if dsn == "" {
|
||||
log.Fatal("NEXARCH_REGISTRY_DSN nicht gesetzt")
|
||||
}
|
||||
addr := os.Getenv("NEXARCH_STATUSPAGE_LISTEN_ADDR")
|
||||
if addr == "" {
|
||||
addr = ":8084"
|
||||
}
|
||||
intervalSeconds := 10
|
||||
if v := os.Getenv("NEXARCH_STATUSPAGE_POLL_INTERVAL_SECONDS"); v != "" {
|
||||
if parsed, err := strconv.Atoi(v); err == nil {
|
||||
intervalSeconds = parsed
|
||||
}
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
pool, err := db.Connect(ctx, dsn)
|
||||
if err != nil {
|
||||
log.Fatalf("db: %v", err)
|
||||
}
|
||||
defer pool.Close()
|
||||
|
||||
store := statuspage.NewStore(pool)
|
||||
checker := statuspage.NewHTTPChecker(2 * time.Second)
|
||||
poller := statuspage.NewPoller(store, checker)
|
||||
go poller.Run(ctx, time.Duration(intervalSeconds)*time.Second)
|
||||
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/status/overview", withCORS(store.OverviewHandler))
|
||||
mux.HandleFunc("/status/history", withCORS(store.HistoryHandler))
|
||||
mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
|
||||
|
||||
log.Printf("statuspage-devserver listening on %s (poll-intervall: %ds)", addr, intervalSeconds)
|
||||
log.Fatal(http.ListenAndServe(addr, mux))
|
||||
}
|
||||
|
||||
func withCORS(next http.HandlerFunc) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Access-Control-Allow-Origin", "*")
|
||||
w.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")
|
||||
w.Header().Set("Access-Control-Allow-Headers", "Content-Type")
|
||||
if r.Method == http.MethodOptions {
|
||||
w.WriteHeader(http.StatusOK)
|
||||
return
|
||||
}
|
||||
next(w, r)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
[Unit]
|
||||
Description=NEXARCH Core - Wiederanlauf-Nachsynchronisierung (API-06/API-11)
|
||||
After=network.target postgresql.service
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
User=nexarch
|
||||
EnvironmentFile=/etc/nexarch/resync-api.env
|
||||
ExecStart=__INSTALL_DIR__/bin/resync-api
|
||||
Restart=on-failure
|
||||
StandardOutput=journal
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
@@ -0,0 +1,76 @@
|
||||
# API-11 – Prüfprotokoll: Wiederanlauf-Nachsynchronisierungs-Endpunkt starten (API-06 als laufender Dienst)
|
||||
|
||||
Voraussetzung API-06 – bereits Fertig, hier UNVERÄNDERT.
|
||||
|
||||
## Reines Wiring, keine neue Logik
|
||||
|
||||
`git diff --stat internal/resync/ internal/audit/ internal/usage/ internal/moduleregistry/`
|
||||
liefert KEINEN Diff gegenüber den jeweiligen Ticket-Ständen. `API-11`
|
||||
fügt ausschließlich `cmd/resync-api/main.go` hinzu — inklusive eines
|
||||
kleinen `auditAdapter`, der `resync.AuditRecorder` (einzelne Felder)
|
||||
auf `audit.Log.Record` (Event-Struct) abbildet. Das ist reine
|
||||
Signatur-Anpassung, keine neue Geschäftslogik.
|
||||
|
||||
## Root Cause (dokumentiert)
|
||||
|
||||
`cmd/core/main.go` ist seit TEN-01 minimal geblieben (nur `/healthz`,
|
||||
`/internal/tenants`) — kein späteres Ticket (RBAC-02, CFG-02, API-06,
|
||||
...) wurde je dort zentral eingehängt. Jedes Modul entstand auf einer
|
||||
eigenen, unabhängigen Feature-Branch-Kette. API-11 folgt dem in dieser
|
||||
Session etablierten Muster (RBAC-06, CFG-05, RET-09): ein eigener,
|
||||
kleiner HTTP-Dienst statt eines zentralen `cmd/core`-Umbaus.
|
||||
|
||||
## Umsetzung
|
||||
|
||||
- `cmd/resync-api/main.go` – startet `internal/resync.Handler` mit
|
||||
echten Produktions-Implementierungen: `moduleregistry.Registry`
|
||||
(Auth), `audit.Log` (über `auditAdapter`), `usage.Store`.
|
||||
- `deploy/systemd/nexarch-resync-api.service.tmpl`.
|
||||
|
||||
## Prüfungen
|
||||
|
||||
| # | Prüfung | Ergebnis |
|
||||
|---|---|---|
|
||||
| 1 | Dienst startet und bleibt stabil (systemctl status aktiv) | **bestanden** – real auf 131: `nexarch-resync-api.service` aktiv, `Restart=on-failure` |
|
||||
| 2 | Realer POST /internal/resync/usage von einem externen Testclient gegen den laufenden Dienst liefert die erwartete Verarbeitung | **bestanden** – real per `curl`: mit echtem, über `moduleregistry.Registry.Provision` ausgestelltem Service-Credential (`X-Nexarch-Client-Id`/`X-Nexarch-Client-Secret`) liefert der Aufruf `{"applied":1}`, `usage_counters` zeigt real den erhöhten Zähler; mit falschem Credential 401. Testdaten (Modul, Credential, Zähler-Zeile) anschließend entfernt |
|
||||
| 3 | Code-Review: keine Änderung an internal/resync/ selbst, nur main.go+systemd neu | **bestanden** – `git diff --stat` bestätigt: `internal/resync/`, `internal/audit/`, `internal/usage/`, `internal/moduleregistry/` unverändert gegenüber ihren jeweiligen Ticket-Ständen |
|
||||
|
||||
## Echte Verdrahtung auf 192.168.1.131
|
||||
|
||||
- `resync-api` gebaut nach `/opt/nexarch-core/bin/`,
|
||||
`/etc/nexarch/resync-api.env` (0600), `nexarch-resync-api.service`
|
||||
installiert/aktiviert.
|
||||
- Reale Rechtevergabe-Lücke gefunden und behoben (gleiches Muster wie
|
||||
bei den vorherigen Wrapper-Diensten): `modules`, `module_credentials`,
|
||||
`audit_events`, `feature_flags`, `usage_counters`,
|
||||
`resync_audit_buffer`, `resync_usage_buffer` gehörten `postgres`,
|
||||
`nexarch_core` hatte keine Rechte — `GRANT` nachgezogen und über
|
||||
`information_schema.role_table_grants` verifiziert, bevor der
|
||||
End-zu-Ende-Test erneut lief.
|
||||
- Zusätzliche reale Erkenntnis: `usage_counters.tenant_id` ist `UUID`,
|
||||
nicht der Tenant-Slug (String) — beim ersten Testversuch mit `"acme"`
|
||||
scheiterte der Insert intern, `UsageHandler` meldete `applied:0` statt
|
||||
eines Fehlers (stiller Fehlschlag pro Delta, so von API-06 selbst so
|
||||
entworfen: "Aufrufer entfernt aus seinem Puffer nur bestätigt
|
||||
übernommene Deltas" — kein API-11-Defekt, sondern korrektes,
|
||||
bestehendes API-06-Verhalten). Mit echter UUID als `tenant_slug`-Wert
|
||||
lieferte der Aufruf real `applied:1`.
|
||||
|
||||
## Build/Test-Ergebnis (192.168.1.131)
|
||||
|
||||
```
|
||||
go build ./... -> clean
|
||||
go vet ./... -> clean
|
||||
golangci-lint run ./cmd/resync-api/... -> 0 issues
|
||||
```
|
||||
|
||||
Keine neuen Go-Tests nötig (kein neuer Fachcode außer main.go/Adapter,
|
||||
die eigentliche Logik ist bereits durch API-06s eigene Tests
|
||||
abgedeckt).
|
||||
|
||||
## Gesamtergebnis
|
||||
|
||||
**Bestanden.** API-06 ist jetzt ein real laufender, über systemd
|
||||
verwalteter Dienst. Modul-Clients wie DMS' `storage.HTTPUsageReporter`
|
||||
(RET-06/DOC-16-Umfeld) können sich jetzt real gegen einen laufenden
|
||||
Endpunkt verdrahten, statt gegen unverdrahteten Go-Code zu testen.
|
||||
@@ -2,7 +2,10 @@ module gitea.perlbach24.de/scripte/nexarch
|
||||
|
||||
go 1.22
|
||||
|
||||
require github.com/jackc/pgx/v5 v5.6.0
|
||||
require (
|
||||
github.com/golang-jwt/jwt/v5 v5.3.1
|
||||
github.com/jackc/pgx/v5 v5.6.0
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/jackc/pgpassfile v1.0.0 // indirect
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
|
||||
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
|
||||
github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY=
|
||||
github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
|
||||
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
|
||||
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
|
||||
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
|
||||
|
||||
@@ -0,0 +1,96 @@
|
||||
// Package audit implementiert Core AUD-01: das zentrale, vom allgemeinen
|
||||
// Anwendungs-Log getrennte Audit-Datenmodell fuer sicherheits- und
|
||||
// compliancerelevante Ereignisse (wer, was, wann, an welchem Tenant).
|
||||
// Unveraenderlichkeit (Append-only) ist AUD-02, Export/Filter-API ist AUD-03
|
||||
// — dieses Paket liefert nur das Datenmodell und den EINEN zentralen
|
||||
// Schreibpfad (Akzeptanzkriterium 3).
|
||||
package audit
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
// SystemTenant ist der reservierte Tenant-Bezug fuer mandantenuebergreifende
|
||||
// Ereignisse (z.B. Superadmin-Aktionen) — es gibt bewusst KEINEN Weg, ein
|
||||
// Ereignis ganz ohne Tenant-Bezug zu schreiben (Akzeptanzkriterium 2).
|
||||
const SystemTenant = "system"
|
||||
|
||||
var ErrMissingTenant = errors.New("audit: tenant_slug darf nicht leer sein")
|
||||
var ErrMissingActor = errors.New("audit: actor darf nicht leer sein")
|
||||
var ErrMissingAction = errors.New("audit: action darf nicht leer sein")
|
||||
|
||||
// Event ist ein strukturiertes Audit-Ereignis (Akzeptanzkriterium 1: Akteur,
|
||||
// Aktion, Zielobjekt, Zeitpunkt, Tenant).
|
||||
type Event struct {
|
||||
TenantSlug string
|
||||
Actor string
|
||||
Action string
|
||||
Target string
|
||||
Metadata map[string]any
|
||||
OccurredAt time.Time
|
||||
}
|
||||
|
||||
// Log ist der EINE zentrale Schreibpfad fuer Audit-Ereignisse — es gibt
|
||||
// bewusst keine zweite Schreibmoeglichkeit, damit kein Handler versehentlich
|
||||
// direkt in audit_events schreibt und dabei die Validierung umgeht
|
||||
// (Akzeptanzkriterium 3).
|
||||
type Log struct {
|
||||
pool *pgxpool.Pool
|
||||
}
|
||||
|
||||
func NewLog(pool *pgxpool.Pool) *Log {
|
||||
return &Log{pool: pool}
|
||||
}
|
||||
|
||||
// Record persistiert genau einen Audit-Eintrag. Fehlender Tenant-Bezug wird
|
||||
// bereits hier abgewiesen (klarer Fehler statt Constraint-Verletzung im
|
||||
// Normalfall) — die Datenbank-CHECK-Constraint aus der Migration ist die
|
||||
// zweite, unumgehbare Verteidigungslinie (Akzeptanzkriterium 2 / Pruefung 2).
|
||||
func (l *Log) Record(ctx context.Context, e Event) error {
|
||||
if e.TenantSlug == "" {
|
||||
return ErrMissingTenant
|
||||
}
|
||||
if e.Actor == "" {
|
||||
return ErrMissingActor
|
||||
}
|
||||
if e.Action == "" {
|
||||
return ErrMissingAction
|
||||
}
|
||||
if e.Metadata == nil {
|
||||
e.Metadata = map[string]any{}
|
||||
}
|
||||
metadataJSON, err := json.Marshal(e.Metadata)
|
||||
if err != nil {
|
||||
return fmt.Errorf("metadaten serialisieren: %w", err)
|
||||
}
|
||||
if e.OccurredAt.IsZero() {
|
||||
e.OccurredAt = time.Now()
|
||||
}
|
||||
|
||||
_, err = l.pool.Exec(ctx, `
|
||||
INSERT INTO audit_events (occurred_at, tenant_slug, actor, action, target, metadata)
|
||||
VALUES ($1, $2, $3, $4, $5, $6)
|
||||
`, e.OccurredAt, e.TenantSlug, e.Actor, e.Action, e.Target, metadataJSON)
|
||||
if err != nil {
|
||||
return fmt.Errorf("audit-ereignis schreiben: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// CountByTenant ist eine schlanke Lesehilfe fuer Tests/Diagnose — die
|
||||
// eigentliche Filter-/Export-API ist AUD-03, hier bewusst nicht vorgezogen.
|
||||
func (l *Log) CountByTenant(ctx context.Context, tenantSlug string) (int, error) {
|
||||
var n int
|
||||
if err := l.pool.QueryRow(ctx, `
|
||||
SELECT count(*) FROM audit_events WHERE tenant_slug = $1
|
||||
`, tenantSlug).Scan(&n); err != nil {
|
||||
return 0, fmt.Errorf("audit-ereignisse zaehlen: %w", err)
|
||||
}
|
||||
return n, nil
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
package audit
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"os"
|
||||
"testing"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
func setupAuditTest(t *testing.T) (*Log, *pgxpool.Pool, func()) {
|
||||
t.Helper()
|
||||
adminDSN := os.Getenv("TEST_ADMIN_DSN")
|
||||
if adminDSN == "" {
|
||||
t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
|
||||
}
|
||||
ctx := context.Background()
|
||||
|
||||
pool, err := pgxpool.New(ctx, adminDSN)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
if _, err := pool.Exec(ctx, `
|
||||
CREATE TABLE IF NOT EXISTS audit_events (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
occurred_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
tenant_slug TEXT NOT NULL CHECK (tenant_slug <> ''),
|
||||
actor TEXT NOT NULL CHECK (actor <> ''),
|
||||
action TEXT NOT NULL CHECK (action <> ''),
|
||||
target TEXT NOT NULL,
|
||||
metadata JSONB NOT NULL DEFAULT '{}'::jsonb
|
||||
)`); err != nil {
|
||||
t.Fatalf("schema: %v", err)
|
||||
}
|
||||
|
||||
cleanup := func() {
|
||||
_, _ = pool.Exec(ctx, `DELETE FROM audit_events WHERE tenant_slug LIKE 'test\_%' ESCAPE '\' OR tenant_slug = $1`, SystemTenant)
|
||||
pool.Close()
|
||||
}
|
||||
return NewLog(pool), pool, cleanup
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 1 + Pruefung 1: ein sicherheitsrelevanter Vorgang
|
||||
// (hier: fehlgeschlagener Login) erzeugt zuverlaessig genau einen Eintrag.
|
||||
func TestRecord_PersistsExactlyOneEventPerSecurityIncident(t *testing.T) {
|
||||
log, pool, cleanup := setupAuditTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
|
||||
err := log.Record(ctx, Event{
|
||||
TenantSlug: "test_acme",
|
||||
Actor: "alice@example.com",
|
||||
Action: "iam.login_failed",
|
||||
Target: "user:alice@example.com",
|
||||
Metadata: map[string]any{"reason": "falsches passwort"},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("record: %v", err)
|
||||
}
|
||||
|
||||
count, err := log.CountByTenant(ctx, "test_acme")
|
||||
if err != nil {
|
||||
t.Fatalf("count: %v", err)
|
||||
}
|
||||
if count != 1 {
|
||||
t.Fatalf("erwartet genau 1 audit-eintrag, habe %d", count)
|
||||
}
|
||||
|
||||
var actor, action, target string
|
||||
if err := pool.QueryRow(ctx, `
|
||||
SELECT actor, action, target FROM audit_events WHERE tenant_slug = 'test_acme'
|
||||
`).Scan(&actor, &action, &target); err != nil {
|
||||
t.Fatalf("eintrag lesen: %v", err)
|
||||
}
|
||||
if actor != "alice@example.com" || action != "iam.login_failed" || target != "user:alice@example.com" {
|
||||
t.Fatalf("eintrag unerwartet: actor=%q action=%q target=%q", actor, action, target)
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 2 + Pruefung 2 (App-Ebene): fehlender Tenant-Bezug wird
|
||||
// bereits vom zentralen Schreibpfad abgewiesen.
|
||||
func TestRecord_RejectsMissingTenant(t *testing.T) {
|
||||
log, _, cleanup := setupAuditTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
|
||||
err := log.Record(ctx, Event{TenantSlug: "", Actor: "alice", Action: "irgendwas"})
|
||||
if !errors.Is(err, ErrMissingTenant) {
|
||||
t.Fatalf("erwartet ErrMissingTenant, habe %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 2 + Pruefung 2 (DB-Ebene): selbst ein direkter INSERT,
|
||||
// der Log.Record umgeht, wird durch die CHECK-Constraint verhindert — der
|
||||
// Schutz haengt nicht allein von der Go-Validierung ab.
|
||||
func TestConstraint_RejectsMissingTenantAtDatabaseLevel(t *testing.T) {
|
||||
_, pool, cleanup := setupAuditTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
|
||||
_, err := pool.Exec(ctx, `
|
||||
INSERT INTO audit_events (tenant_slug, actor, action, target)
|
||||
VALUES ('', 'alice', 'irgendwas', 'ziel')
|
||||
`)
|
||||
if err == nil {
|
||||
t.Fatal("erwartet fehler durch CHECK-constraint bei leerem tenant_slug, habe nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRecord_RejectsMissingActorAndAction(t *testing.T) {
|
||||
log, _, cleanup := setupAuditTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
|
||||
if err := log.Record(ctx, Event{TenantSlug: "test_acme", Actor: "", Action: "x"}); !errors.Is(err, ErrMissingActor) {
|
||||
t.Fatalf("erwartet ErrMissingActor, habe %v", err)
|
||||
}
|
||||
if err := log.Record(ctx, Event{TenantSlug: "test_acme", Actor: "alice", Action: ""}); !errors.Is(err, ErrMissingAction) {
|
||||
t.Fatalf("erwartet ErrMissingAction, habe %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRecord_SystemTenantForCrossTenantEvents(t *testing.T) {
|
||||
log, _, cleanup := setupAuditTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
|
||||
if err := log.Record(ctx, Event{TenantSlug: SystemTenant, Actor: "superadmin", Action: "tenant.provisioned", Target: "tenant:acme"}); err != nil {
|
||||
t.Fatalf("record mit SystemTenant: %v", err)
|
||||
}
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
package health
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
// DatabaseChecker prueft die tatsaechliche Erreichbarkeit der Datenbank
|
||||
// (Ping) — nicht nur, ob der Pool existiert.
|
||||
func DatabaseChecker(pool *pgxpool.Pool) CheckerFunc {
|
||||
return func(ctx context.Context) error {
|
||||
return pool.Ping(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
// QueueChecker prueft, dass die Postgres-basierte Job-Queue (siehe CFG-02)
|
||||
// tatsaechlich abfragbar ist — eine eigene, benannte Abhaengigkeit neben der
|
||||
// reinen DB-Erreichbarkeit (Akzeptanzkriterium 1).
|
||||
func QueueChecker(pool *pgxpool.Pool) CheckerFunc {
|
||||
return func(ctx context.Context) error {
|
||||
_, err := pool.Exec(ctx, `SELECT 1`)
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
package health
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
)
|
||||
|
||||
// LivenessHandler beantwortet IMMER "lebt", solange der Prozess ueberhaupt
|
||||
// HTTP-Anfragen verarbeiten kann — prueft bewusst KEINE externen
|
||||
// Abhaengigkeiten (Akzeptanzkriterium 2: Liveness und Readiness getrennt).
|
||||
// Ein Datenbankausfall darf die Liveness nicht auf "tot" setzen, sonst
|
||||
// wuerde eine Orchestrierung (z.B. systemd/Kubernetes) den Prozess grundlos
|
||||
// neu starten, obwohl nur eine Abhaengigkeit ausgefallen ist.
|
||||
func LivenessHandler(w http.ResponseWriter, r *http.Request) {
|
||||
writeStatus(w, http.StatusOK, map[string]any{"status": "alive"})
|
||||
}
|
||||
|
||||
// ReadinessHandler prueft ALLE registrierten Abhaengigkeiten
|
||||
// (Akzeptanzkriterium 1) und liefert 503, sobald eine davon fehlschlaegt
|
||||
// (Akzeptanzkriterium 3) — unterscheidet sich damit nachweislich von
|
||||
// LivenessHandler im Fehlerfall (Akzeptanzkriterium 2 / Pruefung 3).
|
||||
func (r *Registry) ReadinessHandler() http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, req *http.Request) {
|
||||
ready, results := r.CheckAll(req.Context())
|
||||
|
||||
body := map[string]any{
|
||||
"status": statusText(ready),
|
||||
"checks": results,
|
||||
}
|
||||
status := http.StatusOK
|
||||
if !ready {
|
||||
status = http.StatusServiceUnavailable
|
||||
}
|
||||
writeStatus(w, status, body)
|
||||
}
|
||||
}
|
||||
|
||||
func statusText(ready bool) string {
|
||||
if ready {
|
||||
return "ready"
|
||||
}
|
||||
return "not_ready"
|
||||
}
|
||||
|
||||
func writeStatus(w http.ResponseWriter, status int, body map[string]any) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
_ = json.NewEncoder(w).Encode(body)
|
||||
}
|
||||
@@ -1,86 +0,0 @@
|
||||
// Package health implementiert Core OPS-01: Health-/Readiness-Endpunkte, die
|
||||
// echte Abhaengigkeiten (DB, Job-Queue) statt nur den Prozessstatus pruefen
|
||||
// — wiederverwendbar von Core UND jedem registrierten Modul (siehe API-02),
|
||||
// nicht nur von Core selbst.
|
||||
package health
|
||||
|
||||
import (
|
||||
"context"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Checker prueft EINE Abhaengigkeit (z.B. Datenbank, Job-Queue).
|
||||
type Checker interface {
|
||||
Check(ctx context.Context) error
|
||||
}
|
||||
|
||||
type CheckerFunc func(ctx context.Context) error
|
||||
|
||||
func (f CheckerFunc) Check(ctx context.Context) error { return f(ctx) }
|
||||
|
||||
// DefaultCheckTimeout begrenzt, wie lange EIN einzelner Check maximal
|
||||
// dauern darf, bevor er als fehlgeschlagen gilt — verhindert, dass ein
|
||||
// haengender Check den gesamten Readiness-Endpunkt blockiert
|
||||
// (Akzeptanzkriterium 2 / Pruefung 2: Antwort innerhalb definierter Zeit).
|
||||
const DefaultCheckTimeout = 2 * time.Second
|
||||
|
||||
// Registry haelt alle benannten Checks eines Dienstes.
|
||||
type Registry struct {
|
||||
checks map[string]Checker
|
||||
timeout time.Duration
|
||||
}
|
||||
|
||||
func NewRegistry() *Registry {
|
||||
return &Registry{checks: make(map[string]Checker), timeout: DefaultCheckTimeout}
|
||||
}
|
||||
|
||||
func (r *Registry) WithTimeout(d time.Duration) *Registry {
|
||||
return &Registry{checks: r.checks, timeout: d}
|
||||
}
|
||||
|
||||
// Register fuegt einen benannten Check hinzu (z.B. "database", "queue").
|
||||
func (r *Registry) Register(name string, c Checker) {
|
||||
r.checks[name] = c
|
||||
}
|
||||
|
||||
// Result ist der Ausgang eines einzelnen Checks.
|
||||
type Result struct {
|
||||
OK bool
|
||||
Error string
|
||||
}
|
||||
|
||||
// CheckAll fuehrt alle registrierten Checks NEBENLAEUFIG mit je eigenem
|
||||
// Timeout aus (Akzeptanzkriterium 1: echte Abhaengigkeiten statt Prozess-
|
||||
// status) und liefert ready=false, sobald irgendein Check fehlschlaegt
|
||||
// (Akzeptanzkriterium 3: ein Ausfall wird sichtbar).
|
||||
func (r *Registry) CheckAll(ctx context.Context) (ready bool, results map[string]Result) {
|
||||
type namedResult struct {
|
||||
name string
|
||||
result Result
|
||||
}
|
||||
ch := make(chan namedResult, len(r.checks))
|
||||
|
||||
for name, checker := range r.checks {
|
||||
go func(name string, checker Checker) {
|
||||
checkCtx, cancel := context.WithTimeout(ctx, r.timeout)
|
||||
defer cancel()
|
||||
err := checker.Check(checkCtx)
|
||||
if err != nil {
|
||||
ch <- namedResult{name, Result{OK: false, Error: err.Error()}}
|
||||
return
|
||||
}
|
||||
ch <- namedResult{name, Result{OK: true}}
|
||||
}(name, checker)
|
||||
}
|
||||
|
||||
results = make(map[string]Result, len(r.checks))
|
||||
ready = true
|
||||
for i := 0; i < len(r.checks); i++ {
|
||||
nr := <-ch
|
||||
results[nr.name] = nr.result
|
||||
if !nr.result.OK {
|
||||
ready = false
|
||||
}
|
||||
}
|
||||
return ready, results
|
||||
}
|
||||
@@ -1,161 +0,0 @@
|
||||
package health
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
// Akzeptanzkriterium 1 + Pruefung 1: simulierter Datenbankausfall fuehrt zu
|
||||
// "nicht bereit".
|
||||
func TestReadinessHandler_ReportsNotReadyOnDatabaseFailure(t *testing.T) {
|
||||
adminDSN := os.Getenv("TEST_ADMIN_DSN")
|
||||
if adminDSN == "" {
|
||||
t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
|
||||
}
|
||||
ctx := context.Background()
|
||||
|
||||
pool, err := pgxpool.New(ctx, adminDSN)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
// Datenbankausfall simulieren: Pool sofort schliessen, bevor der Check laeuft.
|
||||
pool.Close()
|
||||
|
||||
reg := NewRegistry()
|
||||
reg.Register("database", DatabaseChecker(pool))
|
||||
|
||||
req := httptest.NewRequest(http.MethodGet, "/readyz", nil)
|
||||
rec := httptest.NewRecorder()
|
||||
reg.ReadinessHandler()(rec, req)
|
||||
|
||||
if rec.Code != http.StatusServiceUnavailable {
|
||||
t.Fatalf("status = %d, want 503 bei db-ausfall", rec.Code)
|
||||
}
|
||||
|
||||
var body struct {
|
||||
Status string `json:"status"`
|
||||
Checks map[string]interface{} `json:"checks"`
|
||||
}
|
||||
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
|
||||
t.Fatalf("body parsen: %v", err)
|
||||
}
|
||||
if body.Status != "not_ready" {
|
||||
t.Fatalf("status-feld = %q, want not_ready", body.Status)
|
||||
}
|
||||
if _, ok := body.Checks["database"]; !ok {
|
||||
t.Fatal("erwartet 'database' im checks-ergebnis")
|
||||
}
|
||||
}
|
||||
|
||||
func TestReadinessHandler_ReportsReadyWhenAllChecksPass(t *testing.T) {
|
||||
adminDSN := os.Getenv("TEST_ADMIN_DSN")
|
||||
if adminDSN == "" {
|
||||
t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
|
||||
}
|
||||
ctx := context.Background()
|
||||
|
||||
pool, err := pgxpool.New(ctx, adminDSN)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
defer pool.Close()
|
||||
|
||||
reg := NewRegistry()
|
||||
reg.Register("database", DatabaseChecker(pool))
|
||||
reg.Register("queue", QueueChecker(pool))
|
||||
|
||||
req := httptest.NewRequest(http.MethodGet, "/readyz", nil)
|
||||
rec := httptest.NewRecorder()
|
||||
reg.ReadinessHandler()(rec, req)
|
||||
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want 200 bei funktionierenden abhaengigkeiten", rec.Code)
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 2 + Pruefung 3: Liveness und Readiness unterscheiden
|
||||
// sich nachweislich im Fehlerfall.
|
||||
func TestLivenessAndReadiness_DifferOnDatabaseFailure(t *testing.T) {
|
||||
adminDSN := os.Getenv("TEST_ADMIN_DSN")
|
||||
if adminDSN == "" {
|
||||
t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
|
||||
}
|
||||
ctx := context.Background()
|
||||
|
||||
pool, err := pgxpool.New(ctx, adminDSN)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
pool.Close() // db-ausfall simulieren
|
||||
|
||||
reg := NewRegistry()
|
||||
reg.Register("database", DatabaseChecker(pool))
|
||||
|
||||
livenessRec := httptest.NewRecorder()
|
||||
LivenessHandler(livenessRec, httptest.NewRequest(http.MethodGet, "/livez", nil))
|
||||
if livenessRec.Code != http.StatusOK {
|
||||
t.Fatalf("liveness status = %d, want 200 trotz db-ausfall (liveness prueft keine abhaengigkeiten)", livenessRec.Code)
|
||||
}
|
||||
|
||||
readinessRec := httptest.NewRecorder()
|
||||
reg.ReadinessHandler()(readinessRec, httptest.NewRequest(http.MethodGet, "/readyz", nil))
|
||||
if readinessRec.Code != http.StatusServiceUnavailable {
|
||||
t.Fatalf("readiness status = %d, want 503 bei db-ausfall", readinessRec.Code)
|
||||
}
|
||||
|
||||
if livenessRec.Code == readinessRec.Code {
|
||||
t.Fatal("liveness und readiness sollten sich im db-ausfall-fall unterscheiden")
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 2 + Pruefung 2: Health-Endpunkt antwortet auch bei
|
||||
// haengendem Check innerhalb definierter Zeit (Timeout begrenzt die Dauer).
|
||||
func TestReadinessHandler_RespondsWithinTimeoutEvenWithHangingCheck(t *testing.T) {
|
||||
reg := NewRegistry().WithTimeout(50 * time.Millisecond)
|
||||
reg.Register("haengender_dienst", CheckerFunc(func(ctx context.Context) error {
|
||||
select {
|
||||
case <-time.After(10 * time.Second): // wuerde ohne timeout ewig blockieren
|
||||
return nil
|
||||
case <-ctx.Done():
|
||||
return ctx.Err()
|
||||
}
|
||||
}))
|
||||
|
||||
start := time.Now()
|
||||
req := httptest.NewRequest(http.MethodGet, "/readyz", nil)
|
||||
rec := httptest.NewRecorder()
|
||||
reg.ReadinessHandler()(rec, req)
|
||||
elapsed := time.Since(start)
|
||||
|
||||
if elapsed > time.Second {
|
||||
t.Fatalf("readiness handler brauchte %s, erwartet deutlich unter 1s durch timeout", elapsed)
|
||||
}
|
||||
if rec.Code != http.StatusServiceUnavailable {
|
||||
t.Fatalf("status = %d, want 503 fuer haengenden/timeout-check", rec.Code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCheckAll_MultipleChecksRunConcurrently(t *testing.T) {
|
||||
reg := NewRegistry().WithTimeout(time.Second)
|
||||
reg.Register("a", CheckerFunc(func(ctx context.Context) error { return nil }))
|
||||
reg.Register("b", CheckerFunc(func(ctx context.Context) error { return errors.New("kaputt") }))
|
||||
|
||||
ready, results := reg.CheckAll(context.Background())
|
||||
if ready {
|
||||
t.Fatal("erwartet ready=false, da 'b' fehlschlaegt")
|
||||
}
|
||||
if !results["a"].OK {
|
||||
t.Fatalf("erwartet 'a' ok, habe %+v", results["a"])
|
||||
}
|
||||
if results["b"].OK || results["b"].Error == "" {
|
||||
t.Fatalf("erwartet 'b' fehlgeschlagen mit fehlertext, habe %+v", results["b"])
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
// Package license implementiert Core LIC-01: Lizenzmodell je Tenant (Plan,
|
||||
// Modul-Umfang, Laufzeit) und die kryptographische Pruefung signierter
|
||||
// Lizenzschluessel. Feature-Flag-AUSWERTUNG zur Laufzeit (LIC-02) und die
|
||||
// Verwaltungsoberflaeche (LIC-04) sind ausdruecklich nicht Teil dieses Pakets
|
||||
// — hier geht es nur um Ausstellung/Validierung/Persistenz (Unleash-Vorbild:
|
||||
// klare Trennung Flag-Verwaltung vs. Flag-Auswertung).
|
||||
package license
|
||||
|
||||
import (
|
||||
"crypto/ed25519"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrInvalidSignature = errors.New("license: signatur ungueltig")
|
||||
ErrMalformedKey = errors.New("license: lizenzschluessel hat ungueltiges format")
|
||||
)
|
||||
|
||||
// Payload ist der signierte Lizenzinhalt (Akzeptanzkriterium 3: Plan,
|
||||
// Modul-Liste, Laufzeit).
|
||||
type Payload struct {
|
||||
TenantSlug string `json:"tenant_slug"`
|
||||
Plan string `json:"plan"`
|
||||
Modules []string `json:"modules"`
|
||||
IssuedAt time.Time `json:"issued_at"`
|
||||
ValidUntil time.Time `json:"valid_until"`
|
||||
}
|
||||
|
||||
// Issuer stellt signierte Lizenzschluessel aus. Haelt den PRIVATEN
|
||||
// Ed25519-Schluessel — lebt in der Praxis beim Lizenzgeber, nicht im
|
||||
// laufenden Core-Prozess (der nur den Validator mit dem oeffentlichen
|
||||
// Schluessel braucht).
|
||||
type Issuer struct {
|
||||
priv ed25519.PrivateKey
|
||||
}
|
||||
|
||||
func NewIssuer(priv ed25519.PrivateKey) *Issuer {
|
||||
return &Issuer{priv: priv}
|
||||
}
|
||||
|
||||
// Issue liefert den Lizenzschluessel im Format base64(payload-json) "." base64(signatur).
|
||||
func (i *Issuer) Issue(payload Payload) (string, error) {
|
||||
raw, err := json.Marshal(payload)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("payload serialisieren: %w", err)
|
||||
}
|
||||
sig := ed25519.Sign(i.priv, raw)
|
||||
|
||||
return base64.RawURLEncoding.EncodeToString(raw) + "." + base64.RawURLEncoding.EncodeToString(sig), nil
|
||||
}
|
||||
|
||||
// Validator prueft Lizenzschluessel gegen den OEFFENTLICHEN Ed25519-Schluessel
|
||||
// — das ist alles, was der laufende Core-Prozess kennen muss.
|
||||
type Validator struct {
|
||||
pub ed25519.PublicKey
|
||||
}
|
||||
|
||||
func NewValidator(pub ed25519.PublicKey) *Validator {
|
||||
return &Validator{pub: pub}
|
||||
}
|
||||
|
||||
// Parse prueft die Signatur (Akzeptanzkriterium 1 / Pruefung 1) und liefert
|
||||
// bei Erfolg den entschluesselten Payload. Ein manipulierter Schluessel wird
|
||||
// hier zuverlaessig erkannt, unabhaengig davon, ob die Laufzeit noch gueltig
|
||||
// waere — Signaturpruefung und Ablaufpruefung sind bewusst getrennt
|
||||
// (Signatur bei Einspielen, Ablauf bei jeder Nutzung, siehe Store.RequireActive).
|
||||
func (v *Validator) Parse(key string) (Payload, error) {
|
||||
rawPart, sigPart, ok := splitOnce(key, '.')
|
||||
if !ok {
|
||||
return Payload{}, ErrMalformedKey
|
||||
}
|
||||
|
||||
raw, err := base64.RawURLEncoding.DecodeString(rawPart)
|
||||
if err != nil {
|
||||
return Payload{}, ErrMalformedKey
|
||||
}
|
||||
sig, err := base64.RawURLEncoding.DecodeString(sigPart)
|
||||
if err != nil {
|
||||
return Payload{}, ErrMalformedKey
|
||||
}
|
||||
|
||||
if !ed25519.Verify(v.pub, raw, sig) {
|
||||
return Payload{}, ErrInvalidSignature
|
||||
}
|
||||
|
||||
var p Payload
|
||||
if err := json.Unmarshal(raw, &p); err != nil {
|
||||
// Signatur war gueltig, aber Payload nicht mehr parsebar — sollte bei
|
||||
// unveraenderten Schluesseln nie vorkommen, trotzdem kein Panic.
|
||||
return Payload{}, fmt.Errorf("%w: payload nicht lesbar", ErrMalformedKey)
|
||||
}
|
||||
return p, nil
|
||||
}
|
||||
|
||||
func splitOnce(s string, sep byte) (before, after string, ok bool) {
|
||||
for i := 0; i < len(s); i++ {
|
||||
if s[i] == sep {
|
||||
return s[:i], s[i+1:], true
|
||||
}
|
||||
}
|
||||
return "", "", false
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
package license
|
||||
|
||||
import (
|
||||
"crypto/ed25519"
|
||||
"errors"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func testKeyPair(t *testing.T) (ed25519.PublicKey, ed25519.PrivateKey) {
|
||||
t.Helper()
|
||||
pub, priv, err := ed25519.GenerateKey(nil)
|
||||
if err != nil {
|
||||
t.Fatalf("schluesselpaar erzeugen: %v", err)
|
||||
}
|
||||
return pub, priv
|
||||
}
|
||||
|
||||
func TestIssueAndParse_RoundTrip(t *testing.T) {
|
||||
pub, priv := testKeyPair(t)
|
||||
issuer := NewIssuer(priv)
|
||||
validator := NewValidator(pub)
|
||||
|
||||
payload := Payload{
|
||||
TenantSlug: "acme",
|
||||
Plan: "pro",
|
||||
Modules: []string{"dms", "mail"},
|
||||
IssuedAt: time.Now().Truncate(time.Second),
|
||||
ValidUntil: time.Now().Add(365 * 24 * time.Hour).Truncate(time.Second),
|
||||
}
|
||||
|
||||
key, err := issuer.Issue(payload)
|
||||
if err != nil {
|
||||
t.Fatalf("issue: %v", err)
|
||||
}
|
||||
|
||||
got, err := validator.Parse(key)
|
||||
if err != nil {
|
||||
t.Fatalf("parse: %v", err)
|
||||
}
|
||||
if got.TenantSlug != payload.TenantSlug || got.Plan != payload.Plan || len(got.Modules) != 2 {
|
||||
t.Fatalf("payload nach parse unerwartet: %+v", got)
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 1 + Pruefung 1: manipulierter Schluessel wird zuverlaessig erkannt.
|
||||
func TestParse_RejectsTamperedKey(t *testing.T) {
|
||||
pub, priv := testKeyPair(t)
|
||||
issuer := NewIssuer(priv)
|
||||
validator := NewValidator(pub)
|
||||
|
||||
key, err := issuer.Issue(Payload{TenantSlug: "acme", Plan: "pro", ValidUntil: time.Now().Add(time.Hour)})
|
||||
if err != nil {
|
||||
t.Fatalf("issue: %v", err)
|
||||
}
|
||||
|
||||
// Ein Zeichen im signierten Teil aendern.
|
||||
tampered := []byte(key)
|
||||
changed := false
|
||||
for i, c := range tampered {
|
||||
if c != '.' {
|
||||
if c == 'A' {
|
||||
tampered[i] = 'B'
|
||||
} else {
|
||||
tampered[i] = 'A'
|
||||
}
|
||||
changed = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !changed {
|
||||
t.Fatal("testaufbau fehlerhaft: nichts zum manipulieren gefunden")
|
||||
}
|
||||
|
||||
if _, err := validator.Parse(string(tampered)); !errors.Is(err, ErrInvalidSignature) {
|
||||
t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParse_RejectsWrongKeyPair(t *testing.T) {
|
||||
_, priv := testKeyPair(t)
|
||||
otherPub, _ := testKeyPair(t)
|
||||
|
||||
issuer := NewIssuer(priv)
|
||||
validator := NewValidator(otherPub) // falscher oeffentlicher Schluessel
|
||||
|
||||
key, err := issuer.Issue(Payload{TenantSlug: "acme", Plan: "pro"})
|
||||
if err != nil {
|
||||
t.Fatalf("issue: %v", err)
|
||||
}
|
||||
if _, err := validator.Parse(key); !errors.Is(err, ErrInvalidSignature) {
|
||||
t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestParse_RejectsMalformedKey(t *testing.T) {
|
||||
pub, _ := testKeyPair(t)
|
||||
validator := NewValidator(pub)
|
||||
|
||||
cases := []string{"", "keine-punkt-trennung", "!!!.!!!"}
|
||||
for _, c := range cases {
|
||||
if _, err := validator.Parse(c); !errors.Is(err, ErrMalformedKey) {
|
||||
t.Fatalf("Parse(%q): erwartet ErrMalformedKey, habe %v", c, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
package license
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrNoLicense = errors.New("license: kein lizenzdatensatz fuer diesen tenant")
|
||||
ErrLicenseExpired = errors.New("license: lizenz abgelaufen")
|
||||
)
|
||||
|
||||
// Store persistiert den Lizenzumfang je Tenant in der Control-Plane-Registry
|
||||
// (siehe internal/tenant.Registry — dieselbe Datenbank, aber ein eigener,
|
||||
// unabhaengiger Store, um internal/tenant nicht um lizenzfremde Belange zu
|
||||
// erweitern).
|
||||
type Store struct {
|
||||
pool *pgxpool.Pool
|
||||
validator *Validator
|
||||
}
|
||||
|
||||
func NewStore(pool *pgxpool.Pool, validator *Validator) *Store {
|
||||
return &Store{pool: pool, validator: validator}
|
||||
}
|
||||
|
||||
// Install prueft die Signatur des Lizenzschluessels (Akzeptanzkriterium 1)
|
||||
// und ersetzt den bisherigen Lizenzdatensatz des Tenants vollstaendig. Ein
|
||||
// bereits abgelaufener, aber korrekt signierter Schluessel wird trotzdem
|
||||
// gespeichert — der Ablauf wird erst bei der Nutzung (RequireActive)
|
||||
// bewertet, nicht beim Einspielen.
|
||||
func (s *Store) Install(ctx context.Context, tenantID, licenseKey string) (Payload, error) {
|
||||
payload, err := s.validator.Parse(licenseKey)
|
||||
if err != nil {
|
||||
return Payload{}, err
|
||||
}
|
||||
|
||||
_, err = s.pool.Exec(ctx, `
|
||||
INSERT INTO tenant_licenses (tenant_id, plan, modules, issued_at, valid_until, raw_key, installed_at)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, now())
|
||||
ON CONFLICT (tenant_id) DO UPDATE SET
|
||||
plan = $2, modules = $3, issued_at = $4, valid_until = $5, raw_key = $6, installed_at = now()
|
||||
`, tenantID, payload.Plan, payload.Modules, payload.IssuedAt, payload.ValidUntil, licenseKey)
|
||||
if err != nil {
|
||||
return Payload{}, fmt.Errorf("lizenz speichern: %w", err)
|
||||
}
|
||||
return payload, nil
|
||||
}
|
||||
|
||||
func (s *Store) get(ctx context.Context, tenantID string) (Payload, error) {
|
||||
var p Payload
|
||||
row := s.pool.QueryRow(ctx, `
|
||||
SELECT plan, modules, issued_at, valid_until
|
||||
FROM tenant_licenses WHERE tenant_id = $1
|
||||
`, tenantID)
|
||||
if err := row.Scan(&p.Plan, &p.Modules, &p.IssuedAt, &p.ValidUntil); err != nil {
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return Payload{}, ErrNoLicense
|
||||
}
|
||||
return Payload{}, fmt.Errorf("lizenz lesen: %w", err)
|
||||
}
|
||||
return p, nil
|
||||
}
|
||||
|
||||
// Status liefert den persistierten Lizenzumfang unabhaengig vom Ablauf
|
||||
// (Akzeptanzkriterium 3: Plan, Modul-Liste, Laufzeit abfragbar).
|
||||
func (s *Store) Status(ctx context.Context, tenantID string) (Payload, error) {
|
||||
return s.get(ctx, tenantID)
|
||||
}
|
||||
|
||||
// RequireActive liefert den Lizenzumfang NUR, wenn die Lizenz noch nicht
|
||||
// abgelaufen ist — sonst ErrLicenseExpired statt eines harten Fehlers/Panics
|
||||
// (Akzeptanzkriterium 2: definierter eingeschraenkter Zustand). Aufrufende
|
||||
// Module (LIC-02/03) entscheiden, was "eingeschraenkt" konkret bedeutet.
|
||||
func (s *Store) RequireActive(ctx context.Context, tenantID string) (Payload, error) {
|
||||
p, err := s.get(ctx, tenantID)
|
||||
if err != nil {
|
||||
return Payload{}, err
|
||||
}
|
||||
if time.Now().After(p.ValidUntil) {
|
||||
return Payload{}, ErrLicenseExpired
|
||||
}
|
||||
return p, nil
|
||||
}
|
||||
@@ -0,0 +1,177 @@
|
||||
package license
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/ed25519"
|
||||
"errors"
|
||||
"os"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
func setupStoreTest(t *testing.T) (*Store, *Issuer, string, func()) {
|
||||
t.Helper()
|
||||
adminDSN := os.Getenv("TEST_ADMIN_DSN")
|
||||
if adminDSN == "" {
|
||||
t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
|
||||
}
|
||||
ctx := context.Background()
|
||||
|
||||
pool, err := pgxpool.New(ctx, adminDSN)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
|
||||
if _, err := pool.Exec(ctx, `
|
||||
CREATE TABLE IF NOT EXISTS tenants (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
slug TEXT NOT NULL UNIQUE,
|
||||
name TEXT NOT NULL,
|
||||
db_name TEXT NOT NULL UNIQUE,
|
||||
db_dsn TEXT NOT NULL,
|
||||
status TEXT NOT NULL DEFAULT 'active',
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS tenant_licenses (
|
||||
tenant_id UUID PRIMARY KEY REFERENCES tenants(id),
|
||||
plan TEXT NOT NULL,
|
||||
modules TEXT[] NOT NULL,
|
||||
issued_at TIMESTAMPTZ NOT NULL,
|
||||
valid_until TIMESTAMPTZ NOT NULL,
|
||||
raw_key TEXT NOT NULL,
|
||||
installed_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
`); err != nil {
|
||||
t.Fatalf("schema: %v", err)
|
||||
}
|
||||
|
||||
var tenantID string
|
||||
if err := pool.QueryRow(ctx, `
|
||||
INSERT INTO tenants (slug, name, db_name, db_dsn)
|
||||
VALUES ('lic_test_tenant', 'Lic Test', 'tenant_lic_test', 'unused')
|
||||
RETURNING id
|
||||
`).Scan(&tenantID); err != nil {
|
||||
t.Fatalf("test-tenant anlegen: %v", err)
|
||||
}
|
||||
|
||||
pub, priv, err := ed25519.GenerateKey(nil)
|
||||
if err != nil {
|
||||
t.Fatalf("schluesselpaar: %v", err)
|
||||
}
|
||||
issuer := NewIssuer(priv)
|
||||
store := NewStore(pool, NewValidator(pub))
|
||||
|
||||
cleanup := func() {
|
||||
_, _ = pool.Exec(ctx, `DELETE FROM tenant_licenses WHERE tenant_id = $1`, tenantID)
|
||||
_, _ = pool.Exec(ctx, `DELETE FROM tenants WHERE id = $1`, tenantID)
|
||||
pool.Close()
|
||||
}
|
||||
return store, issuer, tenantID, cleanup
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 3: Lizenzumfang persistiert und abfragbar.
|
||||
func TestStore_InstallAndStatus(t *testing.T) {
|
||||
store, issuer, tenantID, cleanup := setupStoreTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
|
||||
payload := Payload{
|
||||
TenantSlug: "lic_test_tenant",
|
||||
Plan: "enterprise",
|
||||
Modules: []string{"dms", "mail", "archive"},
|
||||
IssuedAt: time.Now().Truncate(time.Second),
|
||||
ValidUntil: time.Now().Add(30 * 24 * time.Hour).Truncate(time.Second),
|
||||
}
|
||||
key, err := issuer.Issue(payload)
|
||||
if err != nil {
|
||||
t.Fatalf("issue: %v", err)
|
||||
}
|
||||
|
||||
if _, err := store.Install(ctx, tenantID, key); err != nil {
|
||||
t.Fatalf("install: %v", err)
|
||||
}
|
||||
|
||||
status, err := store.Status(ctx, tenantID)
|
||||
if err != nil {
|
||||
t.Fatalf("status: %v", err)
|
||||
}
|
||||
if status.Plan != "enterprise" || len(status.Modules) != 3 {
|
||||
t.Fatalf("status unerwartet: %+v", status)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStore_InstallRejectsInvalidSignature(t *testing.T) {
|
||||
store, _, tenantID, cleanup := setupStoreTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
|
||||
_, otherPriv, _ := ed25519.GenerateKey(nil)
|
||||
foreignIssuer := NewIssuer(otherPriv) // signiert mit falschem schluessel
|
||||
|
||||
key, err := foreignIssuer.Issue(Payload{TenantSlug: "lic_test_tenant", Plan: "pro", ValidUntil: time.Now().Add(time.Hour)})
|
||||
if err != nil {
|
||||
t.Fatalf("issue: %v", err)
|
||||
}
|
||||
|
||||
if _, err := store.Install(ctx, tenantID, key); !errors.Is(err, ErrInvalidSignature) {
|
||||
t.Fatalf("erwartet ErrInvalidSignature, habe %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 2 + Pruefung 2: abgelaufene Lizenz fuehrt zu definiertem
|
||||
// eingeschraenktem Zustand (ErrLicenseExpired), nicht zu einem Absturz.
|
||||
func TestStore_RequireActive_DetectsExpiry(t *testing.T) {
|
||||
store, issuer, tenantID, cleanup := setupStoreTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
|
||||
expired := Payload{
|
||||
TenantSlug: "lic_test_tenant",
|
||||
Plan: "pro",
|
||||
Modules: []string{"dms"},
|
||||
IssuedAt: time.Now().Add(-48 * time.Hour),
|
||||
ValidUntil: time.Now().Add(-24 * time.Hour), // bereits abgelaufen
|
||||
}
|
||||
key, err := issuer.Issue(expired)
|
||||
if err != nil {
|
||||
t.Fatalf("issue: %v", err)
|
||||
}
|
||||
|
||||
// Einspielen einer bereits abgelaufenen, aber korrekt signierten Lizenz
|
||||
// muss funktionieren (Ablauf wird erst bei Nutzung bewertet).
|
||||
if _, err := store.Install(ctx, tenantID, key); err != nil {
|
||||
t.Fatalf("install sollte trotz ablauf funktionieren: %v", err)
|
||||
}
|
||||
|
||||
func() {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
t.Fatalf("RequireActive hat gepanict statt einen fehler zu liefern: %v", r)
|
||||
}
|
||||
}()
|
||||
if _, err := store.RequireActive(ctx, tenantID); !errors.Is(err, ErrLicenseExpired) {
|
||||
t.Fatalf("erwartet ErrLicenseExpired, habe %v", err)
|
||||
}
|
||||
}()
|
||||
|
||||
// Aber der Umfang bleibt weiterhin abfragbar (Status, im Unterschied zu RequireActive).
|
||||
status, err := store.Status(ctx, tenantID)
|
||||
if err != nil {
|
||||
t.Fatalf("status sollte trotz ablauf funktionieren: %v", err)
|
||||
}
|
||||
if status.Plan != "pro" {
|
||||
t.Fatalf("status unerwartet: %+v", status)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStore_RequireActive_NoLicense(t *testing.T) {
|
||||
store, _, tenantID, cleanup := setupStoreTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
|
||||
if _, err := store.RequireActive(ctx, tenantID); !errors.Is(err, ErrNoLicense) {
|
||||
t.Fatalf("erwartet ErrNoLicense, habe %v", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
package moduletrust
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// StaleCache ist der generische Rechte-/Feature-Flag-Cache-Kontrakt
|
||||
// (Akzeptanzkriterium 2): TTL-basiert, mit explizitem, benanntem Verhalten
|
||||
// bei abgelaufenem Cache waehrend Core nicht erreichbar ist.
|
||||
//
|
||||
// - Get: FAIL-OPEN fuer Lesevorgaenge. Schlaegt der Refresh fehl, aber es
|
||||
// gibt bereits einen (wenn auch abgelaufenen) Stand, wird dieser mit
|
||||
// stale=true zurueckgegeben — Begruendung: ein bereits authentifiziertes
|
||||
// Modul soll mit dem letztbekannten Stand weiterarbeiten koennen statt
|
||||
// hart zu blockieren (siehe "Bekannte Fehler vermeiden" im Ticket).
|
||||
// Existiert noch nie ein Stand, gibt es keinen sinnvollen Fallback —
|
||||
// dann liefert auch Get einen Fehler.
|
||||
// - RequireFresh: FAIL-CLOSED fuer sicherheitskritische Aktionen (z.B.
|
||||
// ein komplett NEUER Login). Nutzt NIEMALS einen zwischengespeicherten
|
||||
// Stand, ruft immer frisch ab — Begruendung: eine neue Vertrauens-
|
||||
// entscheidung darf nicht auf veralteten Daten beruhen, auch wenn das
|
||||
// bedeutet, dass die Aktion bei Core-Ausfall sichtbar fehlschlaegt statt
|
||||
// unsicher "irgendwie" durchgelassen zu werden.
|
||||
//
|
||||
// LIC-02 (internal/flag.Service) implementiert bereits denselben Kontrakt
|
||||
// fuer Feature-Flags — StaleCache verallgemeinert dasselbe Muster fuer
|
||||
// JWT-Signaturschluessel, damit beide Faelle derselben dokumentierten
|
||||
// Policy folgen.
|
||||
type StaleCache[T any] struct {
|
||||
mu sync.RWMutex
|
||||
value T
|
||||
hasValue bool
|
||||
fetchedAt time.Time
|
||||
ttl time.Duration
|
||||
fetch func(ctx context.Context) (T, error)
|
||||
}
|
||||
|
||||
func NewStaleCache[T any](ttl time.Duration, fetch func(ctx context.Context) (T, error)) *StaleCache[T] {
|
||||
return &StaleCache[T]{ttl: ttl, fetch: fetch}
|
||||
}
|
||||
|
||||
// Get liefert den Cache-Wert. FAIL-OPEN: bei Refresh-Fehler wird ein
|
||||
// vorhandener, ggf. abgelaufener Stand zurueckgegeben (stale=true).
|
||||
func (c *StaleCache[T]) Get(ctx context.Context) (value T, stale bool, err error) {
|
||||
c.mu.RLock()
|
||||
fresh := c.hasValue && time.Since(c.fetchedAt) < c.ttl
|
||||
if fresh {
|
||||
v := c.value
|
||||
c.mu.RUnlock()
|
||||
return v, false, nil
|
||||
}
|
||||
c.mu.RUnlock()
|
||||
|
||||
newVal, fetchErr := c.fetch(ctx)
|
||||
if fetchErr == nil {
|
||||
c.mu.Lock()
|
||||
c.value, c.hasValue, c.fetchedAt = newVal, true, time.Now()
|
||||
c.mu.Unlock()
|
||||
return newVal, false, nil
|
||||
}
|
||||
|
||||
c.mu.RLock()
|
||||
defer c.mu.RUnlock()
|
||||
if c.hasValue {
|
||||
return c.value, true, nil
|
||||
}
|
||||
var zero T
|
||||
return zero, false, fmt.Errorf("cache leer und refresh fehlgeschlagen: %w", fetchErr)
|
||||
}
|
||||
|
||||
// Invalidate erzwingt beim naechsten Get-Aufruf einen sofortigen Refresh
|
||||
// statt auf den TTL-Ablauf zu warten (API-06, Akzeptanzkriterium 1: ein
|
||||
// Health-Check-getriggerter Wiederanlauf soll den Cache SOFORT aktualisieren,
|
||||
// nicht die reguläre TTL abwarten) — rein additiv, aendert nichts an
|
||||
// Get/RequireFresh (dasselbe Muster wie internal/flag.Service.Invalidate).
|
||||
func (c *StaleCache[T]) Invalidate() {
|
||||
c.mu.Lock()
|
||||
c.hasValue = false
|
||||
c.mu.Unlock()
|
||||
}
|
||||
|
||||
// RequireFresh ruft IMMER frisch ab (FAIL-CLOSED) — fuer sicherheitskritische
|
||||
// Aktionen, die niemals auf einem zwischengespeicherten Stand basieren duerfen.
|
||||
func (c *StaleCache[T]) RequireFresh(ctx context.Context) (T, error) {
|
||||
v, err := c.fetch(ctx)
|
||||
if err != nil {
|
||||
var zero T
|
||||
return zero, fmt.Errorf("core nicht erreichbar, sicherheitskritische aktion abgelehnt: %w", err)
|
||||
}
|
||||
c.mu.Lock()
|
||||
c.value, c.hasValue, c.fetchedAt = v, true, time.Now()
|
||||
c.mu.Unlock()
|
||||
return v, nil
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
package moduletrust
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
)
|
||||
|
||||
type Claims struct {
|
||||
Subject string `json:"sub"`
|
||||
TenantSlug string `json:"tenant"`
|
||||
jwt.RegisteredClaims
|
||||
}
|
||||
|
||||
// Issue signiert ein Token mit dem aktuellen Signierschluessel und traegt
|
||||
// dessen KID im JWT-Header ein — der Verifier auf Modulseite waehlt darueber
|
||||
// den passenden oeffentlichen Schluessel aus PublicKeySet() aus.
|
||||
func (m *KeyManager) Issue(subject, tenantSlug string, ttl time.Duration) (string, error) {
|
||||
key, err := m.SigningKey()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
now := time.Now()
|
||||
claims := Claims{
|
||||
Subject: subject,
|
||||
TenantSlug: tenantSlug,
|
||||
RegisteredClaims: jwt.RegisteredClaims{
|
||||
IssuedAt: jwt.NewNumericDate(now),
|
||||
ExpiresAt: jwt.NewNumericDate(now.Add(ttl)),
|
||||
},
|
||||
}
|
||||
token := jwt.NewWithClaims(jwt.SigningMethodEdDSA, claims)
|
||||
token.Header["kid"] = key.KID
|
||||
return token.SignedString(key.Private)
|
||||
}
|
||||
|
||||
type jwksResponse struct {
|
||||
Keys []jwksKey `json:"keys"`
|
||||
}
|
||||
|
||||
type jwksKey struct {
|
||||
Kid string `json:"kid"`
|
||||
PublicKey string `json:"public_key"` // base64 (raw Ed25519, 32 Byte)
|
||||
}
|
||||
|
||||
// ServeJWKS liefert alle bekannten oeffentlichen Schluessel als JSON —
|
||||
// Module fragen dies periodisch ab (nicht pro Request), siehe Verifier.
|
||||
func (m *KeyManager) ServeJWKS(w http.ResponseWriter, r *http.Request) {
|
||||
set := m.PublicKeySet()
|
||||
resp := jwksResponse{Keys: make([]jwksKey, 0, len(set))}
|
||||
for kid, pub := range set {
|
||||
resp.Keys = append(resp.Keys, jwksKey{Kid: kid, PublicKey: base64.StdEncoding.EncodeToString(pub)})
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_ = json.NewEncoder(w).Encode(resp)
|
||||
}
|
||||
|
||||
// ParseJWKS dekodiert die JSON-Antwort von ServeJWKS zurueck in kid->PublicKey
|
||||
// — Hilfsfunktion fuer Module, die JWKS per HTTP abrufen.
|
||||
func ParseJWKS(data []byte) (map[string][]byte, error) {
|
||||
var resp jwksResponse
|
||||
if err := json.Unmarshal(data, &resp); err != nil {
|
||||
return nil, fmt.Errorf("jwks parsen: %w", err)
|
||||
}
|
||||
out := make(map[string][]byte, len(resp.Keys))
|
||||
for _, k := range resp.Keys {
|
||||
raw, err := base64.StdEncoding.DecodeString(k.PublicKey)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("oeffentlichen schluessel %q dekodieren: %w", k.Kid, err)
|
||||
}
|
||||
out[k.Kid] = raw
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
// Package moduletrust implementiert Core API-05: asymmetrische JWT-Signatur
|
||||
// mit Schluesselverteilung (JWKS), damit DMS/Mail/Archive/Workflow JWTs
|
||||
// LOKAL verifizieren koennen, ohne pro Aufruf einen synchronen Request an
|
||||
// Core zu stellen — Core darf Fundament sein, ohne zum Flaschenhals zu
|
||||
// werden (siehe Entscheidungsverlauf "Vertrauensstellung Core<->Module" in
|
||||
// nexarch-state.json). IAM-02s HS256-Session-Cookie (Browser-Login) bleibt
|
||||
// unangetastet — dies ist ein zusaetzlicher, getrennter Vertrauensmechanismus
|
||||
// fuer Modul-zu-Modul/Modul-zu-Core-Aufrufe.
|
||||
package moduletrust
|
||||
|
||||
import (
|
||||
"crypto/ed25519"
|
||||
"crypto/rand"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"sync"
|
||||
)
|
||||
|
||||
type KeyPair struct {
|
||||
KID string
|
||||
Private ed25519.PrivateKey
|
||||
Public ed25519.PublicKey
|
||||
}
|
||||
|
||||
// KeyManager haelt ALLE noch gueltigen Schluesselpaare — nicht nur das
|
||||
// aktuell signierende. Rotate erzeugt ein neues Paar und behaelt die alten
|
||||
// fuer die Verifikation bereits ausgestellter Tokens (Akzeptanzkriterium 3:
|
||||
// Rotation ohne Ausfallzeit fuer andere Module).
|
||||
type KeyManager struct {
|
||||
mu sync.RWMutex
|
||||
keys []KeyPair // aeltestes zuerst, neuestes zuletzt
|
||||
}
|
||||
|
||||
func NewKeyManager() (*KeyManager, error) {
|
||||
m := &KeyManager{}
|
||||
if _, err := m.Rotate(); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// Rotate erzeugt ein neues Ed25519-Schluesselpaar mit eigener KID und macht
|
||||
// es zum aktuellen Signierschluessel. Aeltere Schluessel bleiben in
|
||||
// PublicKeySet() erhalten, damit bereits ausgestellte Tokens weiterhin
|
||||
// verifizierbar sind.
|
||||
func (m *KeyManager) Rotate() (KeyPair, error) {
|
||||
pub, priv, err := ed25519.GenerateKey(nil)
|
||||
if err != nil {
|
||||
return KeyPair{}, fmt.Errorf("schluesselpaar erzeugen: %w", err)
|
||||
}
|
||||
kidBytes := make([]byte, 8)
|
||||
if _, err := rand.Read(kidBytes); err != nil {
|
||||
return KeyPair{}, fmt.Errorf("kid erzeugen: %w", err)
|
||||
}
|
||||
kp := KeyPair{KID: hex.EncodeToString(kidBytes), Private: priv, Public: pub}
|
||||
|
||||
m.mu.Lock()
|
||||
m.keys = append(m.keys, kp)
|
||||
m.mu.Unlock()
|
||||
return kp, nil
|
||||
}
|
||||
|
||||
// SigningKey liefert den aktuellen (neuesten) Schluessel zum Signieren neuer Tokens.
|
||||
func (m *KeyManager) SigningKey() (KeyPair, error) {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
if len(m.keys) == 0 {
|
||||
return KeyPair{}, fmt.Errorf("moduletrust: kein schluessel vorhanden")
|
||||
}
|
||||
return m.keys[len(m.keys)-1], nil
|
||||
}
|
||||
|
||||
// PublicKeySet liefert ALLE bekannten oeffentlichen Schluessel (kid ->
|
||||
// public key) — die Grundlage fuer den JWKS-Endpunkt.
|
||||
func (m *KeyManager) PublicKeySet() map[string]ed25519.PublicKey {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
out := make(map[string]ed25519.PublicKey, len(m.keys))
|
||||
for _, k := range m.keys {
|
||||
out[k.KID] = k.Public
|
||||
}
|
||||
return out
|
||||
}
|
||||
@@ -0,0 +1,214 @@
|
||||
package moduletrust
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/ed25519"
|
||||
"errors"
|
||||
"net/http"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestIssueAndVerify_RoundTrip(t *testing.T) {
|
||||
km, err := NewKeyManager()
|
||||
if err != nil {
|
||||
t.Fatalf("new key manager: %v", err)
|
||||
}
|
||||
token, err := km.Issue("user-1", "acme", time.Hour)
|
||||
if err != nil {
|
||||
t.Fatalf("issue: %v", err)
|
||||
}
|
||||
|
||||
v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
|
||||
return km.PublicKeySet(), nil
|
||||
})
|
||||
claims, err := v.Verify(context.Background(), token)
|
||||
if err != nil {
|
||||
t.Fatalf("verify: %v", err)
|
||||
}
|
||||
if claims.Subject != "user-1" || claims.TenantSlug != "acme" {
|
||||
t.Fatalf("claims unerwartet: %+v", claims)
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 1: Verifikation lokal, kein Request pro Aufruf.
|
||||
func TestVerify_DoesNotFetchPerCall(t *testing.T) {
|
||||
km, err := NewKeyManager()
|
||||
if err != nil {
|
||||
t.Fatalf("new key manager: %v", err)
|
||||
}
|
||||
token, err := km.Issue("user-1", "acme", time.Hour)
|
||||
if err != nil {
|
||||
t.Fatalf("issue: %v", err)
|
||||
}
|
||||
|
||||
var mu sync.Mutex
|
||||
fetchCalls := 0
|
||||
v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
|
||||
mu.Lock()
|
||||
fetchCalls++
|
||||
mu.Unlock()
|
||||
return km.PublicKeySet(), nil
|
||||
})
|
||||
|
||||
for i := 0; i < 10; i++ {
|
||||
if _, err := v.Verify(context.Background(), token); err != nil {
|
||||
t.Fatalf("verify %d: %v", i, err)
|
||||
}
|
||||
}
|
||||
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
if fetchCalls != 1 {
|
||||
t.Fatalf("erwartet genau 1 fetch fuer 10 Verify-Aufrufe innerhalb der TTL, habe %d", fetchCalls)
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 2 + Pruefung 1: Core simuliert nicht erreichbar,
|
||||
// bereits authentifizierte Nutzer bleiben funktionsfaehig (Fail-Open mit
|
||||
// letztbekanntem Schluesselstand).
|
||||
func TestVerify_FailsOpenWhenCoreUnreachableButStaleKeysExist(t *testing.T) {
|
||||
km, err := NewKeyManager()
|
||||
if err != nil {
|
||||
t.Fatalf("new key manager: %v", err)
|
||||
}
|
||||
token, err := km.Issue("user-1", "acme", time.Hour)
|
||||
if err != nil {
|
||||
t.Fatalf("issue: %v", err)
|
||||
}
|
||||
|
||||
coreDown := false
|
||||
v := NewVerifier(30*time.Millisecond, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
|
||||
if coreDown {
|
||||
return nil, errors.New("core nicht erreichbar (simuliert)")
|
||||
}
|
||||
return km.PublicKeySet(), nil
|
||||
})
|
||||
|
||||
// Cache vorwaermen, waehrend Core noch erreichbar ist.
|
||||
if _, err := v.Verify(context.Background(), token); err != nil {
|
||||
t.Fatalf("verify (warm): %v", err)
|
||||
}
|
||||
|
||||
// "Core abschalten" und TTL ablaufen lassen.
|
||||
coreDown = true
|
||||
time.Sleep(50 * time.Millisecond)
|
||||
|
||||
if _, err := v.Verify(context.Background(), token); err != nil {
|
||||
t.Fatalf("verify sollte trotz core-ausfall mit letztbekanntem stand funktionieren: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 2 + Pruefung 2: neue sicherheitskritische Aktionen
|
||||
// (z.B. neuer Login) schlagen bei Core-Ausfall klar fehl statt unsicher
|
||||
// durchgelassen zu werden — auch wenn ein (aelterer) Cache-Stand existiert.
|
||||
func TestRequireFreshKeys_FailsClosedWhenCoreUnreachable(t *testing.T) {
|
||||
km, err := NewKeyManager()
|
||||
if err != nil {
|
||||
t.Fatalf("new key manager: %v", err)
|
||||
}
|
||||
|
||||
coreDown := false
|
||||
v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
|
||||
if coreDown {
|
||||
return nil, errors.New("core nicht erreichbar (simuliert)")
|
||||
}
|
||||
return km.PublicKeySet(), nil
|
||||
})
|
||||
|
||||
// Cache vorwaermen (existiert jetzt ein "veralteter" gueltiger Stand).
|
||||
if _, _, err := v.cache.Get(context.Background()); err != nil {
|
||||
t.Fatalf("warm cache: %v", err)
|
||||
}
|
||||
|
||||
coreDown = true
|
||||
if err := v.RequireFreshKeys(context.Background()); err == nil {
|
||||
t.Fatal("erwartet fehler (fail-closed) bei core-ausfall, habe nil")
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 3 + Pruefung 3: Schluesselrotation ohne Ausfallzeit —
|
||||
// ein bereits ausgestelltes Token bleibt nach Rotation weiterhin
|
||||
// verifizierbar, ein zweites (simuliertes) Modul bekommt beide Schluessel.
|
||||
func TestRotate_NoDowntimeForAlreadyIssuedTokens(t *testing.T) {
|
||||
km, err := NewKeyManager()
|
||||
if err != nil {
|
||||
t.Fatalf("new key manager: %v", err)
|
||||
}
|
||||
|
||||
oldToken, err := km.Issue("user-1", "acme", time.Hour)
|
||||
if err != nil {
|
||||
t.Fatalf("issue (alt): %v", err)
|
||||
}
|
||||
|
||||
if _, err := km.Rotate(); err != nil {
|
||||
t.Fatalf("rotate: %v", err)
|
||||
}
|
||||
|
||||
newToken, err := km.Issue("user-2", "acme", time.Hour)
|
||||
if err != nil {
|
||||
t.Fatalf("issue (neu): %v", err)
|
||||
}
|
||||
|
||||
// Simuliertes zweites Modul: fragt den vollstaendigen Schluesselsatz ab.
|
||||
moduleB := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
|
||||
return km.PublicKeySet(), nil
|
||||
})
|
||||
|
||||
if _, err := moduleB.Verify(context.Background(), oldToken); err != nil {
|
||||
t.Fatalf("altes token sollte nach rotation weiterhin gueltig sein: %v", err)
|
||||
}
|
||||
if _, err := moduleB.Verify(context.Background(), newToken); err != nil {
|
||||
t.Fatalf("neues token sollte gueltig sein: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestVerify_RejectsUnknownKid(t *testing.T) {
|
||||
km1, _ := NewKeyManager()
|
||||
km2, _ := NewKeyManager() // komplett anderer, unbekannter schluessel
|
||||
|
||||
token, err := km1.Issue("user-1", "acme", time.Hour)
|
||||
if err != nil {
|
||||
t.Fatalf("issue: %v", err)
|
||||
}
|
||||
|
||||
v := NewVerifier(time.Hour, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
|
||||
return km2.PublicKeySet(), nil // kennt km1s schluessel nicht
|
||||
})
|
||||
if _, err := v.Verify(context.Background(), token); !errors.Is(err, ErrInvalidToken) {
|
||||
t.Fatalf("erwartet ErrInvalidToken, habe %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestJWKSRoundTrip(t *testing.T) {
|
||||
km, _ := NewKeyManager()
|
||||
km.Rotate()
|
||||
|
||||
var buf []byte
|
||||
rec := &captureWriter{}
|
||||
km.ServeJWKS(rec, nil)
|
||||
buf = rec.body
|
||||
|
||||
parsed, err := ParseJWKS(buf)
|
||||
if err != nil {
|
||||
t.Fatalf("parse jwks: %v", err)
|
||||
}
|
||||
if len(parsed) != len(km.PublicKeySet()) {
|
||||
t.Fatalf("erwartet %d schluessel, habe %d", len(km.PublicKeySet()), len(parsed))
|
||||
}
|
||||
}
|
||||
|
||||
type captureWriter struct {
|
||||
body []byte
|
||||
header http.Header
|
||||
}
|
||||
|
||||
func (w *captureWriter) Header() http.Header {
|
||||
if w.header == nil {
|
||||
w.header = http.Header{}
|
||||
}
|
||||
return w.header
|
||||
}
|
||||
func (w *captureWriter) Write(p []byte) (int, error) { w.body = append(w.body, p...); return len(p), nil }
|
||||
func (w *captureWriter) WriteHeader(statusCode int) {}
|
||||
@@ -0,0 +1,67 @@
|
||||
package moduletrust
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/ed25519"
|
||||
"errors"
|
||||
"time"
|
||||
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
)
|
||||
|
||||
var ErrInvalidToken = errors.New("moduletrust: ungueltiges token")
|
||||
|
||||
// KeyFetchFunc holt den aktuellen Schluesselsatz von Core (z.B. per HTTP-GET
|
||||
// auf ServeJWKS + ParseJWKS). Wird vom Verifier nur bei abgelaufener TTL
|
||||
// aufgerufen — NICHT bei jeder Verify()-Anfrage (Akzeptanzkriterium 1).
|
||||
type KeyFetchFunc func(ctx context.Context) (map[string]ed25519.PublicKey, error)
|
||||
|
||||
// Verifier ist die Modulseite von API-05: verifiziert JWTs LOKAL gegen einen
|
||||
// per StaleCache zwischengespeicherten Schluesselsatz, ohne pro Aufruf einen
|
||||
// synchronen Request an Core zu stellen.
|
||||
type Verifier struct {
|
||||
cache *StaleCache[map[string]ed25519.PublicKey]
|
||||
}
|
||||
|
||||
func NewVerifier(ttl time.Duration, fetch KeyFetchFunc) *Verifier {
|
||||
return &Verifier{cache: NewStaleCache(ttl, func(ctx context.Context) (map[string]ed25519.PublicKey, error) {
|
||||
return fetch(ctx)
|
||||
})}
|
||||
}
|
||||
|
||||
// Verify prueft die Signatur LOKAL gegen den (ggf. abgelaufenen, aber
|
||||
// vorhandenen) Schluesselsatz — FAIL-OPEN fuer bereits ausgestellte Tokens
|
||||
// (Akzeptanzkriterium 2): ist Core nicht erreichbar, aber ein alter
|
||||
// Schluesselsatz bekannt, wird damit weiter verifiziert.
|
||||
func (v *Verifier) Verify(ctx context.Context, tokenString string) (*Claims, error) {
|
||||
keys, _, err := v.cache.Get(ctx)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
claims := &Claims{}
|
||||
token, err := jwt.ParseWithClaims(tokenString, claims, func(t *jwt.Token) (interface{}, error) {
|
||||
if _, ok := t.Method.(*jwt.SigningMethodEd25519); !ok {
|
||||
return nil, ErrInvalidToken
|
||||
}
|
||||
kid, _ := t.Header["kid"].(string)
|
||||
pub, ok := keys[kid]
|
||||
if !ok {
|
||||
return nil, ErrInvalidToken
|
||||
}
|
||||
return pub, nil
|
||||
})
|
||||
if err != nil || !token.Valid {
|
||||
return nil, ErrInvalidToken
|
||||
}
|
||||
return claims, nil
|
||||
}
|
||||
|
||||
// RequireFreshKeys ruft IMMER frisch von Core ab (FAIL-CLOSED) — fuer
|
||||
// sicherheitskritische Aktionen wie einen komplett neuen Login
|
||||
// (Akzeptanzkriterium 2): schlaegt klar fehl, wenn Core nicht erreichbar
|
||||
// ist, statt auf einem veralteten Schluesselsatz zu vertrauen.
|
||||
func (v *Verifier) RequireFreshKeys(ctx context.Context) error {
|
||||
_, err := v.cache.RequireFresh(ctx)
|
||||
return err
|
||||
}
|
||||
@@ -0,0 +1,155 @@
|
||||
// Package resync implementiert Core API-06: Wiederanlauf & Nachsynchro-
|
||||
// nisierung nach einem Core-Ausfall.
|
||||
//
|
||||
// - Ein Modul puffert Audit-Events und Nutzungszaehler-Deltas LOKAL in
|
||||
// Postgres (NICHT im Speicher — siehe "Bekannte Fehler vermeiden" im
|
||||
// Ticket: ein erneuter Ausfall waehrend der Nachlieferung darf keine
|
||||
// Daten verlieren, eine In-Memory-Queue wuerde das riskieren).
|
||||
// - Ein Health-Check-getriggerter Worker erkennt die Core-Wiedererreich-
|
||||
// barkeit SOFORT (nicht erst nach TTL-Ablauf, siehe StaleCache.Invalidate)
|
||||
// und liefert die gepufferten Daten in ORIGINALER Reihenfolge, authenti-
|
||||
// fiziert ueber das Service-Credential aus API-02
|
||||
// (internal/moduleregistry.Registry.Authenticate).
|
||||
//
|
||||
// Dieses Paket dupliziert weder internal/audit (AUD-01) noch internal/usage
|
||||
// (LIC-03) — es liefert nur den Puffer- und Nachlieferungs-Mechanismus
|
||||
// DAVOR bzw. DANACH.
|
||||
package resync
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
// BufferedAuditEvent ist ein lokal gepuffertes Audit-Ereignis. Seq
|
||||
// garantiert die Wiederherstellung der urspruenglichen Reihenfolge
|
||||
// (Akzeptanzkriterium 2) unabhaengig von eventuellen Uhrzeit-Ungenauigkeiten.
|
||||
type BufferedAuditEvent struct {
|
||||
ID int64
|
||||
Seq int64
|
||||
TenantSlug string
|
||||
Actor string
|
||||
Action string
|
||||
Target string
|
||||
Metadata map[string]any
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
// BufferedUsageDelta ist ein lokal gepuffertes Nutzungszaehler-Inkrement.
|
||||
type BufferedUsageDelta struct {
|
||||
ID int64
|
||||
Seq int64
|
||||
TenantSlug string
|
||||
Metric string
|
||||
Delta int64
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
// Buffer ist die lokale, persistente Pufferqueue eines Moduls.
|
||||
type Buffer struct {
|
||||
pool *pgxpool.Pool
|
||||
}
|
||||
|
||||
func NewBuffer(pool *pgxpool.Pool) *Buffer {
|
||||
return &Buffer{pool: pool}
|
||||
}
|
||||
|
||||
// EnqueueAuditEvent puffert EIN Audit-Ereignis lokal — wird von einem
|
||||
// Fachmodul aufgerufen, wenn Core gerade nicht erreichbar ist (die
|
||||
// Erkennung "Core erreichbar oder nicht" ist NICHT Teil dieses Aufrufs,
|
||||
// siehe Worker).
|
||||
func (b *Buffer) EnqueueAuditEvent(ctx context.Context, tenantSlug, actor, action, target string, metadata map[string]any) error {
|
||||
if metadata == nil {
|
||||
metadata = map[string]any{}
|
||||
}
|
||||
metadataJSON, err := json.Marshal(metadata)
|
||||
if err != nil {
|
||||
return fmt.Errorf("metadata serialisieren: %w", err)
|
||||
}
|
||||
_, err = b.pool.Exec(ctx, `
|
||||
INSERT INTO resync_audit_buffer (tenant_slug, actor, action, target, metadata)
|
||||
VALUES ($1, $2, $3, $4, $5)
|
||||
`, tenantSlug, actor, action, target, metadataJSON)
|
||||
if err != nil {
|
||||
return fmt.Errorf("audit-ereignis puffern: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// EnqueueUsageDelta puffert EIN Nutzungszaehler-Inkrement lokal.
|
||||
func (b *Buffer) EnqueueUsageDelta(ctx context.Context, tenantSlug, metric string, delta int64) error {
|
||||
_, err := b.pool.Exec(ctx, `
|
||||
INSERT INTO resync_usage_buffer (tenant_slug, metric, delta)
|
||||
VALUES ($1, $2, $3)
|
||||
`, tenantSlug, metric, delta)
|
||||
if err != nil {
|
||||
return fmt.Errorf("nutzungsdelta puffern: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// PendingAuditEvents liefert ALLE noch nicht zugestellten Audit-Events in
|
||||
// ORIGINALER Reihenfolge (Akzeptanzkriterium 2 / Pruefung 1).
|
||||
func (b *Buffer) PendingAuditEvents(ctx context.Context) ([]BufferedAuditEvent, error) {
|
||||
rows, err := b.pool.Query(ctx, `
|
||||
SELECT id, seq, tenant_slug, actor, action, target, metadata, created_at
|
||||
FROM resync_audit_buffer ORDER BY seq
|
||||
`)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("gepufferte audit-events abfragen: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var out []BufferedAuditEvent
|
||||
for rows.Next() {
|
||||
var e BufferedAuditEvent
|
||||
var metadataJSON []byte
|
||||
if err := rows.Scan(&e.ID, &e.Seq, &e.TenantSlug, &e.Actor, &e.Action, &e.Target, &metadataJSON, &e.CreatedAt); err != nil {
|
||||
return nil, fmt.Errorf("gepuffertes audit-event lesen: %w", err)
|
||||
}
|
||||
_ = json.Unmarshal(metadataJSON, &e.Metadata)
|
||||
out = append(out, e)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// PendingUsageDeltas liefert ALLE noch nicht zugestellten Nutzungsdeltas.
|
||||
func (b *Buffer) PendingUsageDeltas(ctx context.Context) ([]BufferedUsageDelta, error) {
|
||||
rows, err := b.pool.Query(ctx, `
|
||||
SELECT id, seq, tenant_slug, metric, delta, created_at
|
||||
FROM resync_usage_buffer ORDER BY seq
|
||||
`)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("gepufferte nutzungsdeltas abfragen: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var out []BufferedUsageDelta
|
||||
for rows.Next() {
|
||||
var d BufferedUsageDelta
|
||||
if err := rows.Scan(&d.ID, &d.Seq, &d.TenantSlug, &d.Metric, &d.Delta, &d.CreatedAt); err != nil {
|
||||
return nil, fmt.Errorf("gepuffertes nutzungsdelta lesen: %w", err)
|
||||
}
|
||||
out = append(out, d)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// RemoveAuditEvent entfernt EIN Audit-Event aus dem Puffer — wird NUR nach
|
||||
// von Core BESTAETIGTER Zustellung aufgerufen (Akzeptanzkriterium 2/3: erst
|
||||
// entfernen, wenn sicher zugestellt, sonst bleibt es fuer den naechsten
|
||||
// Versuch erhalten — kein Datenverlust bei erneutem Ausfall waehrend der
|
||||
// Nachlieferung).
|
||||
func (b *Buffer) RemoveAuditEvent(ctx context.Context, id int64) error {
|
||||
_, err := b.pool.Exec(ctx, `DELETE FROM resync_audit_buffer WHERE id = $1`, id)
|
||||
return err
|
||||
}
|
||||
|
||||
func (b *Buffer) RemoveUsageDelta(ctx context.Context, id int64) error {
|
||||
_, err := b.pool.Exec(ctx, `DELETE FROM resync_usage_buffer WHERE id = $1`, id)
|
||||
return err
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
package resync
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
// AuditRecorder ist die schmale Schnittstelle, ueber die Core empfangene
|
||||
// Audit-Events tatsaechlich persistiert. In Produktion durch internal/audit
|
||||
// (AUD-01, nicht Abhaengigkeit dieser Kachel) implementiert — dieses Paket
|
||||
// dupliziert dessen Validierungs-/Speicherlogik NICHT, sondern ruft sie nur
|
||||
// auf. Die Events werden vom Aufrufer sequenziell in PendingAuditEvents-
|
||||
// Reihenfolge uebergeben (Akzeptanzkriterium 2).
|
||||
type AuditRecorder interface {
|
||||
Record(ctx context.Context, tenantSlug, actor, action, target string, metadata map[string]any, occurredAt time.Time) error
|
||||
}
|
||||
|
||||
// UsageIncrementer ist die schmale Schnittstelle zu Core's Nutzungszaehler
|
||||
// (in Produktion internal/usage, LIC-03 — nicht Abhaengigkeit dieser
|
||||
// Kachel). Jedes gepufferte Delta wird GENAU EINMAL angewendet.
|
||||
type UsageIncrementer interface {
|
||||
Increment(ctx context.Context, tenantSlug, metric string, delta int64) error
|
||||
}
|
||||
|
||||
// CredentialAuthenticator ist die schmale Schnittstelle zu API-02s
|
||||
// Service-Credential-Pruefung (internal/moduleregistry.Registry.Authenticate).
|
||||
type CredentialAuthenticator interface {
|
||||
Authenticate(ctx context.Context, clientID, secret string) (moduleName string, ok bool, err error)
|
||||
}
|
||||
|
||||
// Handler nimmt nachgelieferte Audit-Events/Nutzungsdeltas auf der
|
||||
// Core-Seite entgegen — authentifiziert ueber dasselbe Service-Credential
|
||||
// wie jeder andere Modul-Core-Aufruf (Akzeptanzkriterium 2/3, "authentifiziert
|
||||
// ueber das in API-02 definierte Service-Credential").
|
||||
type Handler struct {
|
||||
auth CredentialAuthenticator
|
||||
audit AuditRecorder
|
||||
usage UsageIncrementer
|
||||
}
|
||||
|
||||
func NewHandler(auth CredentialAuthenticator, audit AuditRecorder, usage UsageIncrementer) *Handler {
|
||||
return &Handler{auth: auth, audit: audit, usage: usage}
|
||||
}
|
||||
|
||||
type credentialHeader struct {
|
||||
ClientID string `json:"client_id"`
|
||||
Secret string `json:"secret"`
|
||||
}
|
||||
|
||||
func (h *Handler) authenticate(w http.ResponseWriter, r *http.Request) bool {
|
||||
clientID := r.Header.Get("X-Nexarch-Client-Id")
|
||||
secret := r.Header.Get("X-Nexarch-Client-Secret")
|
||||
_, ok, err := h.auth.Authenticate(r.Context(), clientID, secret)
|
||||
if err != nil || !ok {
|
||||
http.Error(w, "ungueltiges service-credential", http.StatusUnauthorized)
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
type auditEventDTO struct {
|
||||
TenantSlug string `json:"tenant_slug"`
|
||||
Actor string `json:"actor"`
|
||||
Action string `json:"action"`
|
||||
Target string `json:"target"`
|
||||
Metadata map[string]any `json:"metadata"`
|
||||
OccurredAt time.Time `json:"occurred_at"`
|
||||
}
|
||||
|
||||
// AuditHandler nimmt EINE Liste gepufferter Audit-Events entgegen und
|
||||
// schreibt sie SEQUENZIELL in der gegebenen Reihenfolge fort
|
||||
// (Akzeptanzkriterium 2 / Pruefung 1: Vollstaendigkeit + Reihenfolge).
|
||||
// Bricht die Verarbeitung bei einem Fehler ab und meldet, wie viele Events
|
||||
// bereits sicher geschrieben wurden — der Aufrufer (Worker) entfernt aus
|
||||
// seinem lokalen Puffer NUR die bestaetigt geschriebenen Events.
|
||||
func (h *Handler) AuditHandler(w http.ResponseWriter, r *http.Request) {
|
||||
if !h.authenticate(w, r) {
|
||||
return
|
||||
}
|
||||
var events []auditEventDTO
|
||||
if err := json.NewDecoder(r.Body).Decode(&events); err != nil {
|
||||
http.Error(w, "ungueltiger anfrage-koerper", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
written := 0
|
||||
for _, e := range events {
|
||||
if err := h.audit.Record(r.Context(), e.TenantSlug, e.Actor, e.Action, e.Target, e.Metadata, e.OccurredAt); err != nil {
|
||||
break
|
||||
}
|
||||
written++
|
||||
}
|
||||
|
||||
writeJSON(w, map[string]int{"written": written})
|
||||
}
|
||||
|
||||
type usageDeltaDTO struct {
|
||||
TenantSlug string `json:"tenant_slug"`
|
||||
Metric string `json:"metric"`
|
||||
Delta int64 `json:"delta"`
|
||||
}
|
||||
|
||||
// UsageHandler wendet JEDES gepufferte Delta GENAU EINMAL an
|
||||
// (Akzeptanzkriterium 3 / Pruefung 2: keine Doppelzaehlung) — der Aufrufer
|
||||
// entfernt aus seinem lokalen Puffer nur die bestaetigt uebernommenen Deltas.
|
||||
func (h *Handler) UsageHandler(w http.ResponseWriter, r *http.Request) {
|
||||
if !h.authenticate(w, r) {
|
||||
return
|
||||
}
|
||||
var deltas []usageDeltaDTO
|
||||
if err := json.NewDecoder(r.Body).Decode(&deltas); err != nil {
|
||||
http.Error(w, "ungueltiger anfrage-koerper", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
applied := 0
|
||||
for _, d := range deltas {
|
||||
if err := h.usage.Increment(r.Context(), d.TenantSlug, d.Metric, d.Delta); err != nil {
|
||||
break
|
||||
}
|
||||
applied++
|
||||
}
|
||||
|
||||
writeJSON(w, map[string]int{"applied": applied})
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, body any) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_ = json.NewEncoder(w).Encode(body)
|
||||
}
|
||||
@@ -0,0 +1,320 @@
|
||||
package resync
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/flag"
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/moduleregistry"
|
||||
)
|
||||
|
||||
// fakeAudit steht fuer internal/audit.Log (AUD-01, nicht Abhaengigkeit
|
||||
// dieser Kachel) — zeichnet Aufrufe in Empfangsreihenfolge auf, damit
|
||||
// Vollstaendigkeit UND Reihenfolge geprueft werden koennen.
|
||||
type fakeAudit struct {
|
||||
mu sync.Mutex
|
||||
events []auditEventDTO
|
||||
failAt int // -1 = nie fehlschlagen; sonst: ab diesem Index (0-basiert) schlaegt Record fehl
|
||||
}
|
||||
|
||||
func (f *fakeAudit) Record(ctx context.Context, tenantSlug, actor, action, target string, metadata map[string]any, occurredAt time.Time) error {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
if f.failAt >= 0 && len(f.events) == f.failAt {
|
||||
return fmt.Errorf("simulierter core-ausfall waehrend der nachlieferung")
|
||||
}
|
||||
f.events = append(f.events, auditEventDTO{TenantSlug: tenantSlug, Actor: actor, Action: action, Target: target, Metadata: metadata, OccurredAt: occurredAt})
|
||||
return nil
|
||||
}
|
||||
|
||||
// fakeUsage steht fuer internal/usage.Store (LIC-03, nicht Abhaengigkeit
|
||||
// dieser Kachel) — summiert Deltas wie der echte Store.
|
||||
type fakeUsage struct {
|
||||
mu sync.Mutex
|
||||
totals map[string]int64
|
||||
}
|
||||
|
||||
func newFakeUsage() *fakeUsage { return &fakeUsage{totals: map[string]int64{}} }
|
||||
|
||||
func (f *fakeUsage) Increment(ctx context.Context, tenantSlug, metric string, delta int64) error {
|
||||
f.mu.Lock()
|
||||
defer f.mu.Unlock()
|
||||
f.totals[tenantSlug+"|"+metric] += delta
|
||||
return nil
|
||||
}
|
||||
|
||||
func setupTest(t *testing.T) (*Buffer, *pgxpool.Pool, func()) {
|
||||
t.Helper()
|
||||
adminDSN := os.Getenv("TEST_ADMIN_DSN")
|
||||
if adminDSN == "" {
|
||||
t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
|
||||
}
|
||||
ctx := context.Background()
|
||||
|
||||
pool, err := pgxpool.New(ctx, adminDSN)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
if _, err := pool.Exec(ctx, `
|
||||
CREATE TABLE IF NOT EXISTS resync_audit_buffer (
|
||||
id BIGSERIAL PRIMARY KEY, seq BIGSERIAL, tenant_slug TEXT NOT NULL, actor TEXT NOT NULL,
|
||||
action TEXT NOT NULL, target TEXT NOT NULL DEFAULT '', metadata JSONB NOT NULL DEFAULT '{}',
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS resync_usage_buffer (
|
||||
id BIGSERIAL PRIMARY KEY, seq BIGSERIAL, tenant_slug TEXT NOT NULL, metric TEXT NOT NULL,
|
||||
delta BIGINT NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS feature_flags (
|
||||
key TEXT PRIMARY KEY, enabled BOOLEAN NOT NULL DEFAULT false,
|
||||
rollout_percentage INT NOT NULL DEFAULT 0, target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS modules (
|
||||
name TEXT PRIMARY KEY, version TEXT NOT NULL CHECK (version <> ''),
|
||||
required_flags TEXT[] NOT NULL DEFAULT '{}', registered_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS module_credentials (
|
||||
module_name TEXT PRIMARY KEY REFERENCES modules(name),
|
||||
client_id TEXT NOT NULL UNIQUE, secret_hash BYTEA NOT NULL,
|
||||
issued_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
`); err != nil {
|
||||
t.Fatalf("schema: %v", err)
|
||||
}
|
||||
|
||||
cleanup := func() { pool.Close() }
|
||||
return NewBuffer(pool), pool, cleanup
|
||||
}
|
||||
|
||||
func uniqueModuleName() string {
|
||||
return fmt.Sprintf("resync-test-%d", time.Now().UnixNano())
|
||||
}
|
||||
|
||||
// setupModuleCredential registriert ein echtes Modul + Service-Credential
|
||||
// ueber internal/moduleregistry (API-02) — dieselbe Authentifizierung wird
|
||||
// vom Handler tatsaechlich geprueft, kein Mock.
|
||||
func setupModuleCredential(t *testing.T, pool *pgxpool.Pool) (registry *moduleregistry.Registry, clientID, secret string) {
|
||||
t.Helper()
|
||||
ctx := context.Background()
|
||||
flagService := flag.NewService(flag.NewStore(pool), 10*time.Millisecond)
|
||||
registry = moduleregistry.NewRegistry(pool, flagService)
|
||||
name := uniqueModuleName()
|
||||
if _, err := registry.Register(ctx, name, "1.0.0", nil); err != nil {
|
||||
t.Fatalf("modul registrieren: %v", err)
|
||||
}
|
||||
clientID, secret, err := registry.Provision(ctx, name)
|
||||
if err != nil {
|
||||
t.Fatalf("credential provisionieren: %v", err)
|
||||
}
|
||||
return registry, clientID, secret
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 2 + Pruefung 1: waehrend eines simulierten Ausfalls
|
||||
// lokal gepufferte Audit-Events sind nach Wiederanlauf vollstaendig und in
|
||||
// korrekter Reihenfolge in Core's Audit-Log vorhanden.
|
||||
func TestFlushAll_DeliversBufferedAuditEventsCompleteAndInOrder(t *testing.T) {
|
||||
buffer, pool, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
registry, clientID, secret := setupModuleCredential(t, pool)
|
||||
|
||||
tenantSlug := "acme"
|
||||
// Ereignisse "waehrend core down" lokal puffern.
|
||||
actions := []string{"login", "upload", "delete", "logout"}
|
||||
for _, action := range actions {
|
||||
if err := buffer.EnqueueAuditEvent(ctx, tenantSlug, "user-1", action, "res-1", nil); err != nil {
|
||||
t.Fatalf("enqueue %s: %v", action, err)
|
||||
}
|
||||
}
|
||||
|
||||
audit := &fakeAudit{failAt: -1}
|
||||
usage := newFakeUsage()
|
||||
handler := NewHandler(registry, audit, usage)
|
||||
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/internal/resync/audit", handler.AuditHandler)
|
||||
mux.HandleFunc("/internal/resync/usage", handler.UsageHandler)
|
||||
mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
|
||||
server := httptest.NewServer(mux)
|
||||
defer server.Close()
|
||||
|
||||
client := NewCoreClient(server.URL, clientID, secret)
|
||||
worker := NewWorker(buffer, client)
|
||||
|
||||
if err := worker.FlushAll(ctx); err != nil {
|
||||
t.Fatalf("flushall: %v", err)
|
||||
}
|
||||
|
||||
audit.mu.Lock()
|
||||
defer audit.mu.Unlock()
|
||||
if len(audit.events) != len(actions) {
|
||||
t.Fatalf("erwartet %d zugestellte events, habe %d", len(actions), len(audit.events))
|
||||
}
|
||||
for i, e := range audit.events {
|
||||
if e.Action != actions[i] {
|
||||
t.Fatalf("reihenfolge falsch: position %d = %q, want %q", i, e.Action, actions[i])
|
||||
}
|
||||
}
|
||||
|
||||
// Puffer muss nach bestaetigter Zustellung leer sein.
|
||||
remaining, err := buffer.PendingAuditEvents(ctx)
|
||||
if err != nil {
|
||||
t.Fatalf("pending: %v", err)
|
||||
}
|
||||
if len(remaining) != 0 {
|
||||
t.Fatalf("erwartet leeren puffer nach bestaetigter zustellung, habe %d verbleibende", len(remaining))
|
||||
}
|
||||
}
|
||||
|
||||
// Bekannter-Fehler-Praevention: bricht die Zustellung waehrend der
|
||||
// Nachlieferung erneut ab (Core faellt wieder aus), bleiben die NICHT
|
||||
// bestaetigten Events sicher im Puffer erhalten statt verloren zu gehen.
|
||||
func TestFlushAll_KeepsUnconfirmedEventsInBufferOnPartialFailure(t *testing.T) {
|
||||
buffer, pool, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
registry, clientID, secret := setupModuleCredential(t, pool)
|
||||
|
||||
for i := 0; i < 5; i++ {
|
||||
if err := buffer.EnqueueAuditEvent(ctx, "acme", "user-1", fmt.Sprintf("action-%d", i), "", nil); err != nil {
|
||||
t.Fatalf("enqueue %d: %v", i, err)
|
||||
}
|
||||
}
|
||||
|
||||
// Core-Fake schlaegt AB dem 3. Event fehl -> simuliert erneuten Ausfall
|
||||
// mitten in der Nachlieferung.
|
||||
audit := &fakeAudit{failAt: 3}
|
||||
handler := NewHandler(registry, audit, newFakeUsage())
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/internal/resync/audit", handler.AuditHandler)
|
||||
mux.HandleFunc("/internal/resync/usage", handler.UsageHandler)
|
||||
server := httptest.NewServer(mux)
|
||||
defer server.Close()
|
||||
|
||||
client := NewCoreClient(server.URL, clientID, secret)
|
||||
worker := NewWorker(buffer, client)
|
||||
|
||||
if err := worker.FlushAll(ctx); err == nil {
|
||||
t.Fatal("erwartet fehler, da core nur teilweise bestaetigt hat")
|
||||
}
|
||||
|
||||
remaining, err := buffer.PendingAuditEvents(ctx)
|
||||
if err != nil {
|
||||
t.Fatalf("pending: %v", err)
|
||||
}
|
||||
if len(remaining) != 2 {
|
||||
t.Fatalf("erwartet 2 verbleibende (nicht bestaetigte) events im puffer, habe %d", len(remaining))
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 3 + Pruefung 2: Nutzungszaehler-Differenz aus der
|
||||
// Ausfallzeit wird korrekt nachgebucht, ein wiederholter (fehlerhafter)
|
||||
// Flush-Versuch fuehrt NICHT zu Doppelzaehlung, weil bereits bestaetigte
|
||||
// Deltas aus dem Puffer entfernt sind.
|
||||
func TestFlushAll_AppliesUsageDeltasWithoutDoubleCounting(t *testing.T) {
|
||||
buffer, pool, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
registry, clientID, secret := setupModuleCredential(t, pool)
|
||||
|
||||
deltas := []int64{3, 5, 2}
|
||||
var want int64
|
||||
for _, d := range deltas {
|
||||
want += d
|
||||
if err := buffer.EnqueueUsageDelta(ctx, "acme", "api_calls", d); err != nil {
|
||||
t.Fatalf("enqueue delta %d: %v", d, err)
|
||||
}
|
||||
}
|
||||
|
||||
usage := newFakeUsage()
|
||||
handler := NewHandler(registry, &fakeAudit{failAt: -1}, usage)
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/internal/resync/audit", handler.AuditHandler)
|
||||
mux.HandleFunc("/internal/resync/usage", handler.UsageHandler)
|
||||
server := httptest.NewServer(mux)
|
||||
defer server.Close()
|
||||
|
||||
client := NewCoreClient(server.URL, clientID, secret)
|
||||
worker := NewWorker(buffer, client)
|
||||
|
||||
if err := worker.FlushAll(ctx); err != nil {
|
||||
t.Fatalf("flushall 1: %v", err)
|
||||
}
|
||||
|
||||
usage.mu.Lock()
|
||||
got := usage.totals["acme|api_calls"]
|
||||
usage.mu.Unlock()
|
||||
if got != want {
|
||||
t.Fatalf("nutzungsstand nach nachbuchung = %d, want %d", got, want)
|
||||
}
|
||||
|
||||
// Ein zweiter Flush-Versuch (z.B. redundanter Retry) darf NICHTS mehr
|
||||
// nachbuchen, da der Puffer bereits geleert wurde.
|
||||
if err := worker.FlushAll(ctx); err != nil {
|
||||
t.Fatalf("flushall 2: %v", err)
|
||||
}
|
||||
usage.mu.Lock()
|
||||
got2 := usage.totals["acme|api_calls"]
|
||||
usage.mu.Unlock()
|
||||
if got2 != want {
|
||||
t.Fatalf("nutzungsstand nach redundantem zweiten flush = %d, want unveraendert %d (keine doppelzaehlung)", got2, want)
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 1 + Pruefung 3: bei erkannter Core-Wiedererreichbarkeit
|
||||
// wird der Cache SOFORT invalidiert (naechster Zugriff refetcht), nicht
|
||||
// erst nach TTL-Ablauf — Latenz wird gemessen und liegt weit unter einer
|
||||
// langen TTL.
|
||||
func TestCheckAndSync_InvalidatesCacheImmediatelyOnRecovery(t *testing.T) {
|
||||
buffer, pool, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
registry, clientID, secret := setupModuleCredential(t, pool)
|
||||
_ = registry
|
||||
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
|
||||
server := httptest.NewServer(mux)
|
||||
defer server.Close()
|
||||
|
||||
client := NewCoreClient(server.URL, clientID, secret)
|
||||
worker := NewWorker(buffer, client)
|
||||
|
||||
invalidated := false
|
||||
var mu sync.Mutex
|
||||
worker.OnReachable(func() {
|
||||
mu.Lock()
|
||||
invalidated = true
|
||||
mu.Unlock()
|
||||
})
|
||||
|
||||
start := time.Now()
|
||||
becameReachable, err := worker.CheckAndSync(context.Background())
|
||||
elapsed := time.Since(start)
|
||||
if err != nil {
|
||||
t.Fatalf("checkandsync: %v", err)
|
||||
}
|
||||
if !becameReachable {
|
||||
t.Fatal("erwartet erkannten uebergang zu 'erreichbar' beim ersten erfolgreichen check")
|
||||
}
|
||||
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
if !invalidated {
|
||||
t.Fatal("erwartet sofortigen cache-invalidierungs-callback bei core-wiedererreichbarkeit")
|
||||
}
|
||||
// Zielwert: deutlich unter einer typischen TTL (z.B. 5s beim
|
||||
// Feature-Flag-Cache, LIC-02) — hier im Millisekundenbereich, da rein
|
||||
// lokal ohne Netzwerk-Overhead.
|
||||
if elapsed > time.Second {
|
||||
t.Fatalf("cache-invalidierung brauchte %s, erwartet deutlich unter 1s", elapsed)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,220 @@
|
||||
package resync
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
// CoreClient ist der modul-seitige HTTP-Client fuer die Nachlieferung,
|
||||
// authentifiziert ueber dasselbe Service-Credential wie jeder andere
|
||||
// Modul-Core-Aufruf (API-02).
|
||||
type CoreClient struct {
|
||||
BaseURL string
|
||||
ClientID string
|
||||
Secret string
|
||||
HTTP *http.Client
|
||||
}
|
||||
|
||||
func NewCoreClient(baseURL, clientID, secret string) *CoreClient {
|
||||
return &CoreClient{BaseURL: baseURL, ClientID: clientID, Secret: secret, HTTP: &http.Client{Timeout: 5 * time.Second}}
|
||||
}
|
||||
|
||||
func (c *CoreClient) post(ctx context.Context, path string, body any) (*http.Response, error) {
|
||||
payload, err := json.Marshal(body)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("payload serialisieren: %w", err)
|
||||
}
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL+path, bytes.NewReader(payload))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
req.Header.Set("X-Nexarch-Client-Id", c.ClientID)
|
||||
req.Header.Set("X-Nexarch-Client-Secret", c.Secret)
|
||||
return c.HTTP.Do(req)
|
||||
}
|
||||
|
||||
// HealthCheck prueft, ob Core erreichbar ist — dieselbe Konvention wie
|
||||
// internal/health (OPS-01): HTTP 200 auf einem Health-Endpunkt.
|
||||
func (c *CoreClient) HealthCheck(ctx context.Context) bool {
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.BaseURL+"/healthz", nil)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
resp, err := c.HTTP.Do(req)
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
return resp.StatusCode == http.StatusOK
|
||||
}
|
||||
|
||||
// Worker erkennt Core-Wiedererreichbarkeit und stoesst DANN sofort
|
||||
// (Akzeptanzkriterium 1) sowohl registrierte Cache-Invalidierungen als auch
|
||||
// das Nachliefern des lokalen Puffers an.
|
||||
type Worker struct {
|
||||
buffer *Buffer
|
||||
client *CoreClient
|
||||
onReachable []func()
|
||||
wasDown bool
|
||||
}
|
||||
|
||||
func NewWorker(buffer *Buffer, client *CoreClient) *Worker {
|
||||
return &Worker{buffer: buffer, client: client, wasDown: true} // Start pessimistisch: erster erfolgreicher Check zaehlt als "Wiedererreichbarkeit".
|
||||
}
|
||||
|
||||
// OnReachable registriert einen Callback, der bei jeder erkannten
|
||||
// Core-Wiedererreichbarkeit sofort ausgefuehrt wird — z.B.
|
||||
// moduletrust.StaleCache[T].Invalidate, damit der naechste Zugriff sofort
|
||||
// neu abruft statt auf TTL-Ablauf zu warten (Akzeptanzkriterium 1).
|
||||
func (w *Worker) OnReachable(fn func()) {
|
||||
w.onReachable = append(w.onReachable, fn)
|
||||
}
|
||||
|
||||
// CheckAndSync fuehrt EINEN Zyklus aus: Erreichbarkeit pruefen, bei
|
||||
// erkanntem UEBERGANG "nicht erreichbar -> erreichbar" sofort die
|
||||
// registrierten Callbacks ausloesen und den Puffer nachliefern. Gibt
|
||||
// zurueck, ob ein Wiederanlauf in diesem Aufruf erkannt wurde (fuer
|
||||
// Latenzmessung in Tests, Pruefung 3).
|
||||
func (w *Worker) CheckAndSync(ctx context.Context) (becameReachable bool, err error) {
|
||||
reachable := w.client.HealthCheck(ctx)
|
||||
if !reachable {
|
||||
w.wasDown = true
|
||||
return false, nil
|
||||
}
|
||||
|
||||
justRecovered := w.wasDown
|
||||
w.wasDown = false
|
||||
if !justRecovered {
|
||||
return false, nil
|
||||
}
|
||||
|
||||
for _, fn := range w.onReachable {
|
||||
fn()
|
||||
}
|
||||
|
||||
if err := w.FlushAll(ctx); err != nil {
|
||||
return true, err
|
||||
}
|
||||
return true, nil
|
||||
}
|
||||
|
||||
// FlushAll liefert ZUERST alle gepufferten Audit-Events (in Reihenfolge),
|
||||
// DANN alle gepufferten Nutzungsdeltas nach. Jedes Element wird aus dem
|
||||
// lokalen Puffer NUR entfernt, wenn Core es bestaetigt hat — bricht die
|
||||
// Uebertragung vorzeitig ab (Core faellt waehrend der Nachlieferung erneut
|
||||
// aus), bleibt der Rest sicher im Postgres-Puffer erhalten
|
||||
// (Akzeptanzkriterium 2/3, "Bekannte Fehler vermeiden").
|
||||
func (w *Worker) FlushAll(ctx context.Context) error {
|
||||
if err := w.flushAuditEvents(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
return w.flushUsageDeltas(ctx)
|
||||
}
|
||||
|
||||
func (w *Worker) flushAuditEvents(ctx context.Context) error {
|
||||
events, err := w.buffer.PendingAuditEvents(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(events) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
dtos := make([]auditEventDTO, len(events))
|
||||
for i, e := range events {
|
||||
dtos[i] = auditEventDTO{
|
||||
TenantSlug: e.TenantSlug, Actor: e.Actor, Action: e.Action, Target: e.Target,
|
||||
Metadata: e.Metadata, OccurredAt: e.CreatedAt,
|
||||
}
|
||||
}
|
||||
|
||||
resp, err := w.client.post(ctx, "/internal/resync/audit", dtos)
|
||||
if err != nil {
|
||||
return fmt.Errorf("audit-nachlieferung: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return fmt.Errorf("audit-nachlieferung: unerwarteter status %d", resp.StatusCode)
|
||||
}
|
||||
|
||||
var ack struct {
|
||||
Written int `json:"written"`
|
||||
}
|
||||
if err := json.NewDecoder(resp.Body).Decode(&ack); err != nil {
|
||||
return fmt.Errorf("audit-bestaetigung lesen: %w", err)
|
||||
}
|
||||
|
||||
// NUR die von Core bestaetigt geschriebenen Events entfernen — sie sind
|
||||
// nach PendingAuditEvents-Reihenfolge sortiert, die ersten `Written`
|
||||
// Eintraege entsprechen also genau den bestaetigten.
|
||||
for i := 0; i < ack.Written; i++ {
|
||||
if err := w.buffer.RemoveAuditEvent(ctx, events[i].ID); err != nil {
|
||||
return fmt.Errorf("bestaetigtes audit-event aus puffer entfernen: %w", err)
|
||||
}
|
||||
}
|
||||
if ack.Written < len(events) {
|
||||
return fmt.Errorf("core hat nur %d von %d audit-events bestaetigt", ack.Written, len(events))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (w *Worker) flushUsageDeltas(ctx context.Context) error {
|
||||
deltas, err := w.buffer.PendingUsageDeltas(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if len(deltas) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
dtos := make([]usageDeltaDTO, len(deltas))
|
||||
for i, d := range deltas {
|
||||
dtos[i] = usageDeltaDTO{TenantSlug: d.TenantSlug, Metric: d.Metric, Delta: d.Delta}
|
||||
}
|
||||
|
||||
resp, err := w.client.post(ctx, "/internal/resync/usage", dtos)
|
||||
if err != nil {
|
||||
return fmt.Errorf("nutzungs-nachlieferung: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return fmt.Errorf("nutzungs-nachlieferung: unerwarteter status %d", resp.StatusCode)
|
||||
}
|
||||
|
||||
var ack struct {
|
||||
Applied int `json:"applied"`
|
||||
}
|
||||
if err := json.NewDecoder(resp.Body).Decode(&ack); err != nil {
|
||||
return fmt.Errorf("nutzungs-bestaetigung lesen: %w", err)
|
||||
}
|
||||
|
||||
for i := 0; i < ack.Applied; i++ {
|
||||
if err := w.buffer.RemoveUsageDelta(ctx, deltas[i].ID); err != nil {
|
||||
return fmt.Errorf("bestaetigtes nutzungsdelta aus puffer entfernen: %w", err)
|
||||
}
|
||||
}
|
||||
if ack.Applied < len(deltas) {
|
||||
return fmt.Errorf("core hat nur %d von %d nutzungsdeltas bestaetigt", ack.Applied, len(deltas))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Run fuehrt CheckAndSync in festen Abstaenden aus — die "kurze, definierte
|
||||
// Zeitspanne" aus Akzeptanzkriterium 1 ist dieses Poll-Intervall.
|
||||
func (w *Worker) Run(ctx context.Context, interval time.Duration) {
|
||||
ticker := time.NewTicker(interval)
|
||||
defer ticker.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-ticker.C:
|
||||
_, _ = w.CheckAndSync(ctx)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,273 +0,0 @@
|
||||
// Package statuspage implementiert Core OPS-02: eine zentrale Statusseite,
|
||||
// die den Health-Zustand aller registrierten Module aggregiert und den
|
||||
// Verlauf vergangener Statusaenderungen speichert. Baut auf OPS-01
|
||||
// (internal/health) auf, indem es GENAU die dort etablierten
|
||||
// Readiness-Endpunkte je Modul abfragt — dieses Paket dupliziert keine
|
||||
// Health-Check-Logik, es aggregiert nur deren Ergebnisse ueber die Zeit.
|
||||
package statuspage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
// Status ist der aggregierte Zustand EINES Moduls zu einem Zeitpunkt.
|
||||
type Status string
|
||||
|
||||
const (
|
||||
StatusUp Status = "up"
|
||||
StatusDown Status = "down"
|
||||
)
|
||||
|
||||
// Target ist ein zu ueberwachendes Modul mit seiner Readiness-URL
|
||||
// (OPS-01-Endpunkt, z.B. "http://dms:8080/readyz"). Eigenstaendige
|
||||
// Konfiguration statt Erweiterung von internal/moduleregistry.Module, um
|
||||
// API-02 nicht anzufassen (Kein Umbau angrenzender Bereiche).
|
||||
type Target struct {
|
||||
Name string
|
||||
HealthURL string
|
||||
}
|
||||
|
||||
// Store persistiert Ueberwachungsziele und den Verlauf ihrer
|
||||
// Statusaenderungen.
|
||||
type Store struct {
|
||||
pool *pgxpool.Pool
|
||||
}
|
||||
|
||||
func NewStore(pool *pgxpool.Pool) *Store {
|
||||
return &Store{pool: pool}
|
||||
}
|
||||
|
||||
// RegisterTarget traegt ein zu ueberwachendes Modul ein oder aktualisiert
|
||||
// dessen URL (Akzeptanzkriterium 1: "aller registrierten Module").
|
||||
func (s *Store) RegisterTarget(ctx context.Context, t Target) error {
|
||||
_, err := s.pool.Exec(ctx, `
|
||||
INSERT INTO status_targets (name, health_url)
|
||||
VALUES ($1, $2)
|
||||
ON CONFLICT (name) DO UPDATE SET health_url = $2
|
||||
`, t.Name, t.HealthURL)
|
||||
if err != nil {
|
||||
return fmt.Errorf("ueberwachungsziel speichern: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Store) ListTargets(ctx context.Context) ([]Target, error) {
|
||||
rows, err := s.pool.Query(ctx, `SELECT name, health_url FROM status_targets ORDER BY name`)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("ueberwachungsziele auflisten: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var out []Target
|
||||
for rows.Next() {
|
||||
var t Target
|
||||
if err := rows.Scan(&t.Name, &t.HealthURL); err != nil {
|
||||
return nil, fmt.Errorf("ueberwachungsziel lesen: %w", err)
|
||||
}
|
||||
out = append(out, t)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// recordIfChanged schreibt NUR dann einen neuen Verlaufseintrag, wenn sich
|
||||
// der Status seit dem letzten Eintrag geaendert hat (oder es der erste
|
||||
// Eintrag ist) — der Verlauf zeigt Statusaenderungen (Akzeptanzkriterium 3),
|
||||
// nicht jede einzelne Abfrage.
|
||||
func (s *Store) recordIfChanged(ctx context.Context, name string, status Status) error {
|
||||
var lastStatus string
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT status FROM status_history WHERE name = $1 ORDER BY changed_at DESC LIMIT 1
|
||||
`, name).Scan(&lastStatus)
|
||||
if err != nil && err != pgx.ErrNoRows {
|
||||
return fmt.Errorf("letzten status lesen: %w", err)
|
||||
}
|
||||
if err == nil && lastStatus == string(status) {
|
||||
return nil // keine Aenderung, kein neuer Eintrag
|
||||
}
|
||||
|
||||
if _, err := s.pool.Exec(ctx, `
|
||||
INSERT INTO status_history (name, status, changed_at) VALUES ($1, $2, now())
|
||||
`, name, string(status)); err != nil {
|
||||
return fmt.Errorf("statuseintrag schreiben: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// ModuleStatus ist der aktuelle Zustand EINES Moduls fuer die Uebersicht.
|
||||
type ModuleStatus struct {
|
||||
Name string `json:"name"`
|
||||
Status Status `json:"status"`
|
||||
LastChecked time.Time `json:"last_checked"`
|
||||
}
|
||||
|
||||
// Overview liefert den aktuellen (letzten bekannten) Status jedes
|
||||
// registrierten Ziels (Akzeptanzkriterium 1). Ziele ohne jemals erfolgte
|
||||
// Pruefung erscheinen mit Status "down" — ein Modul, ueber das nichts
|
||||
// bekannt ist, gilt als nicht verfuegbar (Fail-Safe-Default), nicht als
|
||||
// stillschweigend "ok".
|
||||
func (s *Store) Overview(ctx context.Context) ([]ModuleStatus, error) {
|
||||
targets, err := s.ListTargets(ctx)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
out := make([]ModuleStatus, 0, len(targets))
|
||||
for _, t := range targets {
|
||||
var status string
|
||||
var changedAt time.Time
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT status, changed_at FROM status_history WHERE name = $1 ORDER BY changed_at DESC LIMIT 1
|
||||
`, t.Name).Scan(&status, &changedAt)
|
||||
if err == pgx.ErrNoRows {
|
||||
out = append(out, ModuleStatus{Name: t.Name, Status: StatusDown})
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("aktuellen status lesen (%s): %w", t.Name, err)
|
||||
}
|
||||
out = append(out, ModuleStatus{Name: t.Name, Status: Status(status), LastChecked: changedAt})
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// HistoryEntry ist EIN Verlaufseintrag (Akzeptanzkriterium 3).
|
||||
type HistoryEntry struct {
|
||||
Status Status `json:"status"`
|
||||
ChangedAt time.Time `json:"changed_at"`
|
||||
}
|
||||
|
||||
func (s *Store) History(ctx context.Context, name string) ([]HistoryEntry, error) {
|
||||
rows, err := s.pool.Query(ctx, `
|
||||
SELECT status, changed_at FROM status_history WHERE name = $1 ORDER BY changed_at DESC
|
||||
`, name)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("verlauf abfragen: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var out []HistoryEntry
|
||||
for rows.Next() {
|
||||
var e HistoryEntry
|
||||
var status string
|
||||
if err := rows.Scan(&status, &e.ChangedAt); err != nil {
|
||||
return nil, fmt.Errorf("verlaufseintrag lesen: %w", err)
|
||||
}
|
||||
e.Status = Status(status)
|
||||
out = append(out, e)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// HTTPChecker fragt die Readiness-URL eines Moduls ab (OPS-01-Endpunkt) und
|
||||
// liefert StatusUp NUR bei HTTP 200 — jeder andere Statuscode ODER ein
|
||||
// Netzwerkfehler/Timeout gilt als StatusDown. Ein einzelnes nicht
|
||||
// erreichbares Modul liefert einen FEHLERFREIEN StatusDown-Wert statt eines
|
||||
// Go-Errors, damit Poller.Run ein fehlerhaftes Modul niemals mit einem
|
||||
// anderen verwechseln oder den gesamten Zyklus abbrechen kann
|
||||
// (Akzeptanzkriterium 2).
|
||||
type HTTPChecker struct {
|
||||
Client *http.Client
|
||||
Timeout time.Duration
|
||||
}
|
||||
|
||||
func NewHTTPChecker(timeout time.Duration) *HTTPChecker {
|
||||
return &HTTPChecker{Client: &http.Client{}, Timeout: timeout}
|
||||
}
|
||||
|
||||
func (c *HTTPChecker) Check(ctx context.Context, url string) Status {
|
||||
ctx, cancel := context.WithTimeout(ctx, c.Timeout)
|
||||
defer cancel()
|
||||
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
|
||||
if err != nil {
|
||||
return StatusDown
|
||||
}
|
||||
resp, err := c.Client.Do(req)
|
||||
if err != nil {
|
||||
return StatusDown
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode == http.StatusOK {
|
||||
return StatusUp
|
||||
}
|
||||
return StatusDown
|
||||
}
|
||||
|
||||
// Poller fragt periodisch alle Ziele ab und schreibt Statusaenderungen fort.
|
||||
type Poller struct {
|
||||
store *Store
|
||||
checker *HTTPChecker
|
||||
}
|
||||
|
||||
func NewPoller(store *Store, checker *HTTPChecker) *Poller {
|
||||
return &Poller{store: store, checker: checker}
|
||||
}
|
||||
|
||||
// PollOnce prueft ALLE Ziele in einem Durchlauf. Ein fehlschlagendes Ziel
|
||||
// (Netzwerkfehler, Timeout, Nicht-200) wird als StatusDown vermerkt und
|
||||
// haelt die Pruefung der UEBRIGEN Ziele nicht auf — die Schleife laeuft
|
||||
// sequenziell weiter, kein Ziel kann ein anderes blockieren
|
||||
// (Akzeptanzkriterium 2 / Pruefung 2).
|
||||
func (p *Poller) PollOnce(ctx context.Context) error {
|
||||
targets, err := p.store.ListTargets(ctx)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, t := range targets {
|
||||
status := p.checker.Check(ctx, t.HealthURL)
|
||||
if err := p.store.recordIfChanged(ctx, t.Name, status); err != nil {
|
||||
// Ein Schreibfehler fuer EIN Ziel darf die Pruefung der anderen
|
||||
// nicht verhindern — dieselbe Fail-Isolation wie bei einem
|
||||
// unerreichbaren Modul.
|
||||
continue
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Run ruft PollOnce in festen Abstaenden auf, bis ctx beendet wird —
|
||||
// dieselbe Konvention wie internal/tenant.Lifecycle.RunSweeper.
|
||||
func (p *Poller) Run(ctx context.Context, interval time.Duration) {
|
||||
ticker := time.NewTicker(interval)
|
||||
defer ticker.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-ticker.C:
|
||||
_ = p.PollOnce(ctx)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// --- HTTP-Bindung fuer die Oberflaeche ---
|
||||
|
||||
func (s *Store) OverviewHandler(w http.ResponseWriter, r *http.Request) {
|
||||
overview, err := s.Overview(r.Context())
|
||||
writeJSONResult(w, overview, err)
|
||||
}
|
||||
|
||||
func (s *Store) HistoryHandler(w http.ResponseWriter, r *http.Request) {
|
||||
name := r.URL.Query().Get("name")
|
||||
history, err := s.History(r.Context(), name)
|
||||
writeJSONResult(w, history, err)
|
||||
}
|
||||
|
||||
func writeJSONResult(w http.ResponseWriter, body any, err error) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
if err != nil {
|
||||
w.WriteHeader(http.StatusInternalServerError)
|
||||
_ = json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
w.WriteHeader(http.StatusOK)
|
||||
_ = json.NewEncoder(w).Encode(body)
|
||||
}
|
||||
@@ -1,198 +0,0 @@
|
||||
package statuspage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
func setupTest(t *testing.T) (*Store, func()) {
|
||||
t.Helper()
|
||||
adminDSN := os.Getenv("TEST_ADMIN_DSN")
|
||||
if adminDSN == "" {
|
||||
t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
|
||||
}
|
||||
ctx := context.Background()
|
||||
|
||||
pool, err := pgxpool.New(ctx, adminDSN)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
if _, err := pool.Exec(ctx, `
|
||||
CREATE TABLE IF NOT EXISTS status_targets (name TEXT PRIMARY KEY, health_url TEXT NOT NULL);
|
||||
CREATE TABLE IF NOT EXISTS status_history (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(), name TEXT NOT NULL, status TEXT NOT NULL,
|
||||
changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
`); err != nil {
|
||||
t.Fatalf("schema: %v", err)
|
||||
}
|
||||
|
||||
cleanup := func() { pool.Close() }
|
||||
return NewStore(pool), cleanup
|
||||
}
|
||||
|
||||
func uniqueName(prefix string) string {
|
||||
return fmt.Sprintf("%s-%d", prefix, time.Now().UnixNano())
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 1: Uebersicht zeigt den Status ALLER registrierten
|
||||
// Module.
|
||||
func TestOverview_ShowsAllRegisteredModules(t *testing.T) {
|
||||
store, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
|
||||
up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
|
||||
defer up.Close()
|
||||
|
||||
nameA, nameB := uniqueName("mod-a"), uniqueName("mod-b")
|
||||
if err := store.RegisterTarget(ctx, Target{Name: nameA, HealthURL: up.URL}); err != nil {
|
||||
t.Fatalf("target a: %v", err)
|
||||
}
|
||||
if err := store.RegisterTarget(ctx, Target{Name: nameB, HealthURL: up.URL}); err != nil {
|
||||
t.Fatalf("target b: %v", err)
|
||||
}
|
||||
|
||||
poller := NewPoller(store, NewHTTPChecker(time.Second))
|
||||
if err := poller.PollOnce(ctx); err != nil {
|
||||
t.Fatalf("poll: %v", err)
|
||||
}
|
||||
|
||||
overview, err := store.Overview(ctx)
|
||||
if err != nil {
|
||||
t.Fatalf("overview: %v", err)
|
||||
}
|
||||
// Overview() listet ALLE jemals registrierten Ziele (auch aus fruehreren
|
||||
// Testlaeufen auf derselben geteilten Test-DB) — hier wird deshalb nur
|
||||
// der Status von nameA/nameB geprueft, nicht jeder Eintrag der Tabelle.
|
||||
statusByName := map[string]Status{}
|
||||
for _, m := range overview {
|
||||
statusByName[m.Name] = m.Status
|
||||
}
|
||||
if statusByName[nameA] != StatusUp {
|
||||
t.Fatalf("modul %s: status = %s, want up", nameA, statusByName[nameA])
|
||||
}
|
||||
if statusByName[nameB] != StatusUp {
|
||||
t.Fatalf("modul %s: status = %s, want up", nameB, statusByName[nameB])
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 2 + Pruefung 1/2: ein simulierter Ausfall eines Moduls
|
||||
// wird sichtbar, das ANDERE Modul bleibt unbeeinflusst und die Pruefung
|
||||
// beider laeuft trotzdem in einem Durchlauf durch (kein Totalausfall).
|
||||
func TestPollOnce_IsolatesFailingModuleFromOthers(t *testing.T) {
|
||||
store, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
|
||||
up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
|
||||
defer up.Close()
|
||||
down := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusInternalServerError) }))
|
||||
down.Close() // Server sofort schliessen -> Verbindung tatsaechlich unerreichbar (simulierter Ausfall)
|
||||
|
||||
healthyName, downName := uniqueName("healthy"), uniqueName("down")
|
||||
if err := store.RegisterTarget(ctx, Target{Name: healthyName, HealthURL: up.URL}); err != nil {
|
||||
t.Fatalf("target healthy: %v", err)
|
||||
}
|
||||
if err := store.RegisterTarget(ctx, Target{Name: downName, HealthURL: down.URL}); err != nil {
|
||||
t.Fatalf("target down: %v", err)
|
||||
}
|
||||
|
||||
poller := NewPoller(store, NewHTTPChecker(500*time.Millisecond))
|
||||
if err := poller.PollOnce(ctx); err != nil {
|
||||
t.Fatalf("poll haette trotz einem ausgefallenen modul erfolgreich durchlaufen sollen: %v", err)
|
||||
}
|
||||
|
||||
overview, err := store.Overview(ctx)
|
||||
if err != nil {
|
||||
t.Fatalf("overview: %v", err)
|
||||
}
|
||||
statusByName := map[string]Status{}
|
||||
for _, m := range overview {
|
||||
statusByName[m.Name] = m.Status
|
||||
}
|
||||
if statusByName[healthyName] != StatusUp {
|
||||
t.Fatalf("healthy modul: status = %s, want up", statusByName[healthyName])
|
||||
}
|
||||
if statusByName[downName] != StatusDown {
|
||||
t.Fatalf("ausgefallenes modul: status = %s, want down", statusByName[downName])
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 3: Verlauf vergangener Statusaenderungen ist einsehbar.
|
||||
func TestHistory_RecordsStatusTransitions(t *testing.T) {
|
||||
store, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
name := uniqueName("flaky")
|
||||
|
||||
up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
|
||||
defer up.Close()
|
||||
if err := store.RegisterTarget(ctx, Target{Name: name, HealthURL: up.URL}); err != nil {
|
||||
t.Fatalf("target: %v", err)
|
||||
}
|
||||
|
||||
poller := NewPoller(store, NewHTTPChecker(time.Second))
|
||||
if err := poller.PollOnce(ctx); err != nil {
|
||||
t.Fatalf("poll 1: %v", err)
|
||||
}
|
||||
|
||||
// Ziel wird "abgeschaltet" (URL zeigt jetzt auf einen bereits
|
||||
// geschlossenen Server) -> naechster Poll erkennt den Statuswechsel.
|
||||
closedURL := up.URL
|
||||
up.Close()
|
||||
if err := store.RegisterTarget(ctx, Target{Name: name, HealthURL: closedURL}); err != nil {
|
||||
t.Fatalf("target aktualisieren: %v", err)
|
||||
}
|
||||
if err := poller.PollOnce(ctx); err != nil {
|
||||
t.Fatalf("poll 2: %v", err)
|
||||
}
|
||||
|
||||
history, err := store.History(ctx, name)
|
||||
if err != nil {
|
||||
t.Fatalf("history: %v", err)
|
||||
}
|
||||
if len(history) != 2 {
|
||||
t.Fatalf("erwartet genau 2 statuswechsel (up -> down), habe %d: %+v", len(history), history)
|
||||
}
|
||||
if history[0].Status != StatusDown || history[1].Status != StatusUp {
|
||||
t.Fatalf("erwartet verlauf [down, up] (neueste zuerst), habe: %+v", history)
|
||||
}
|
||||
}
|
||||
|
||||
// Wiederholte Polls OHNE Statuswechsel duerfen den Verlauf nicht mit
|
||||
// identischen Eintraegen fluten (siehe recordIfChanged).
|
||||
func TestHistory_DoesNotDuplicateUnchangedStatus(t *testing.T) {
|
||||
store, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
name := uniqueName("stable")
|
||||
|
||||
up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) }))
|
||||
defer up.Close()
|
||||
if err := store.RegisterTarget(ctx, Target{Name: name, HealthURL: up.URL}); err != nil {
|
||||
t.Fatalf("target: %v", err)
|
||||
}
|
||||
|
||||
poller := NewPoller(store, NewHTTPChecker(time.Second))
|
||||
for i := 0; i < 3; i++ {
|
||||
if err := poller.PollOnce(ctx); err != nil {
|
||||
t.Fatalf("poll %d: %v", i, err)
|
||||
}
|
||||
}
|
||||
|
||||
history, err := store.History(ctx, name)
|
||||
if err != nil {
|
||||
t.Fatalf("history: %v", err)
|
||||
}
|
||||
if len(history) != 1 {
|
||||
t.Fatalf("erwartet genau 1 eintrag trotz 3 unveraenderter polls, habe %d", len(history))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
package usage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"log/slog"
|
||||
"time"
|
||||
)
|
||||
|
||||
// AggregateFunc berechnet/aktualisiert Zaehlerstaende aus einer autoritativen
|
||||
// Quelle (z.B. "zaehle Zeilen in einer Modul-Tabelle") — die konkrete Quelle
|
||||
// haengt vom jeweiligen Modul ab und ist nicht Teil dieser Kachel. Das
|
||||
// Aggregations-Grundgerüst selbst (periodischer Trigger) ist es.
|
||||
type AggregateFunc func(ctx context.Context) error
|
||||
|
||||
// RunPeriodicAggregation ruft aggregate in festen Abstaenden auf, bis ctx
|
||||
// beendet wird — dieselbe In-Prozess-Worker-Goroutine-Konvention wie
|
||||
// internal/tenant.Lifecycle.RunSweeper (Akzeptanzkriterium 1: "periodisch
|
||||
// aggregiert").
|
||||
func RunPeriodicAggregation(ctx context.Context, interval time.Duration, aggregate AggregateFunc) {
|
||||
ticker := time.NewTicker(interval)
|
||||
defer ticker.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-ticker.C:
|
||||
if err := aggregate(ctx); err != nil {
|
||||
slog.Error("nutzungszaehler-aggregation fehlgeschlagen", "error", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
// Package usage implementiert Core LIC-03: Nutzungszaehler je Tenant
|
||||
// (Benutzeranzahl, Speicherverbrauch, API-Aufrufe, ...) und die Pruefung
|
||||
// gegen konfigurierte Quotas. Quotas sind Konfiguration (Tabellenzeile), kein
|
||||
// Hardcode — Zitadel/Unleash-Vorbild.
|
||||
package usage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
var ErrNoQuota = errors.New("usage: keine quota fuer diese metrik konfiguriert")
|
||||
|
||||
// Status ist die definierte Reaktion einer Quota-Pruefung (Akzeptanzkriterium 2).
|
||||
type Status string
|
||||
|
||||
const (
|
||||
StatusOK Status = "ok"
|
||||
StatusWarning Status = "warning" // Schwelle (80%) erreicht, aber noch nicht ueberschritten
|
||||
StatusExceeded Status = "exceeded" // Quota ueberschritten — neue Ressourcen sollten gesperrt werden
|
||||
)
|
||||
|
||||
// warningThreshold liegt bei 80% der Quota.
|
||||
const warningThreshold = 0.8
|
||||
|
||||
type Store struct {
|
||||
pool *pgxpool.Pool
|
||||
}
|
||||
|
||||
func NewStore(pool *pgxpool.Pool) *Store {
|
||||
return &Store{pool: pool}
|
||||
}
|
||||
|
||||
// Increment erhoeht einen Zaehler ATOMAR ueber ein einziges SQL-Statement
|
||||
// (UPSERT mit value = value + delta) statt Read-Modify-Write in Go — das
|
||||
// haelt Zaehlerstaende bei parallelen Schreibzugriffen konsistent
|
||||
// (Akzeptanzkriterium 1 / Pruefung 2), ohne eine Anwendungs-Transaktion mit
|
||||
// Lock zu brauchen.
|
||||
func (s *Store) Increment(ctx context.Context, tenantID, metric string, delta int64) error {
|
||||
_, err := s.pool.Exec(ctx, `
|
||||
INSERT INTO usage_counters (tenant_id, metric, value, updated_at)
|
||||
VALUES ($1, $2, $3, now())
|
||||
ON CONFLICT (tenant_id, metric) DO UPDATE
|
||||
SET value = usage_counters.value + $3, updated_at = now()
|
||||
`, tenantID, metric, delta)
|
||||
if err != nil {
|
||||
return fmt.Errorf("zaehler erhoehen: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Get liefert den aktuellen Zaehlerstand — 0, wenn noch nie erhoeht wurde.
|
||||
// Der Wert ist strikt tenant-gescoped (Akzeptanzkriterium 3 / Pruefung 3).
|
||||
func (s *Store) Get(ctx context.Context, tenantID, metric string) (int64, error) {
|
||||
var value int64
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT value FROM usage_counters WHERE tenant_id = $1 AND metric = $2
|
||||
`, tenantID, metric).Scan(&value)
|
||||
if err != nil {
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return 0, nil
|
||||
}
|
||||
return 0, fmt.Errorf("zaehler lesen: %w", err)
|
||||
}
|
||||
return value, nil
|
||||
}
|
||||
|
||||
// SetQuota legt die Obergrenze fuer (tenantID, metric) fest — Konfiguration,
|
||||
// kein Hardcode.
|
||||
func (s *Store) SetQuota(ctx context.Context, tenantID, metric string, limit int64) error {
|
||||
_, err := s.pool.Exec(ctx, `
|
||||
INSERT INTO usage_quotas (tenant_id, metric, limit_value)
|
||||
VALUES ($1, $2, $3)
|
||||
ON CONFLICT (tenant_id, metric) DO UPDATE SET limit_value = $3
|
||||
`, tenantID, metric, limit)
|
||||
if err != nil {
|
||||
return fmt.Errorf("quota setzen: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Store) GetQuota(ctx context.Context, tenantID, metric string) (int64, error) {
|
||||
var limit int64
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT limit_value FROM usage_quotas WHERE tenant_id = $1 AND metric = $2
|
||||
`, tenantID, metric).Scan(&limit)
|
||||
if err != nil {
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return 0, ErrNoQuota
|
||||
}
|
||||
return 0, fmt.Errorf("quota lesen: %w", err)
|
||||
}
|
||||
return limit, nil
|
||||
}
|
||||
|
||||
// Check liefert Zaehlerstand, konfigurierte Quota und die daraus abgeleitete
|
||||
// Reaktion (Akzeptanzkriterium 2 / Pruefung 1). Ist keine Quota konfiguriert,
|
||||
// gilt die Metrik als unbegrenzt (StatusOK).
|
||||
func (s *Store) Check(ctx context.Context, tenantID, metric string) (value, limit int64, status Status, err error) {
|
||||
value, err = s.Get(ctx, tenantID, metric)
|
||||
if err != nil {
|
||||
return 0, 0, "", err
|
||||
}
|
||||
|
||||
limit, err = s.GetQuota(ctx, tenantID, metric)
|
||||
if errors.Is(err, ErrNoQuota) {
|
||||
return value, 0, StatusOK, nil
|
||||
}
|
||||
if err != nil {
|
||||
return 0, 0, "", err
|
||||
}
|
||||
|
||||
switch {
|
||||
case value > limit:
|
||||
return value, limit, StatusExceeded, nil
|
||||
case limit > 0 && float64(value) >= warningThreshold*float64(limit):
|
||||
return value, limit, StatusWarning, nil
|
||||
default:
|
||||
return value, limit, StatusOK, nil
|
||||
}
|
||||
}
|
||||
|
||||
// Reaction wird aufgerufen, wenn Check einen Nicht-OK-Status liefert
|
||||
// (Akzeptanzkriterium 2: "definierte Reaktion").
|
||||
type Reaction func(ctx context.Context, tenantID, metric string, value, limit int64, status Status)
|
||||
|
||||
// Enforce fuehrt Check aus und ruft react auf, wenn der Status nicht OK ist —
|
||||
// die konkrete "Sperre neuer Ressourcen"/Benachrichtigung liegt beim
|
||||
// Aufrufer (z.B. TEN-02 vor dem Anlegen eines neuen Benutzers), Enforce
|
||||
// garantiert nur, dass die Reaktion zuverlaessig ausgeloest wird.
|
||||
func (s *Store) Enforce(ctx context.Context, tenantID, metric string, react Reaction) (Status, error) {
|
||||
value, limit, status, err := s.Check(ctx, tenantID, metric)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if status != StatusOK && react != nil {
|
||||
react(ctx, tenantID, metric, value, limit, status)
|
||||
}
|
||||
return status, nil
|
||||
}
|
||||
@@ -0,0 +1,206 @@
|
||||
package usage
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"os"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
func setupTest(t *testing.T) (*Store, func()) {
|
||||
t.Helper()
|
||||
adminDSN := os.Getenv("TEST_ADMIN_DSN")
|
||||
if adminDSN == "" {
|
||||
t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
|
||||
}
|
||||
ctx := context.Background()
|
||||
|
||||
pool, err := pgxpool.New(ctx, adminDSN)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
if _, err := pool.Exec(ctx, `
|
||||
CREATE TABLE IF NOT EXISTS usage_counters (
|
||||
tenant_id UUID NOT NULL, metric TEXT NOT NULL, value BIGINT NOT NULL DEFAULT 0,
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (tenant_id, metric)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS usage_quotas (
|
||||
tenant_id UUID NOT NULL, metric TEXT NOT NULL, limit_value BIGINT NOT NULL,
|
||||
PRIMARY KEY (tenant_id, metric)
|
||||
);
|
||||
`); err != nil {
|
||||
t.Fatalf("schema: %v", err)
|
||||
}
|
||||
|
||||
cleanup := func() { pool.Close() }
|
||||
return NewStore(pool), cleanup
|
||||
}
|
||||
|
||||
func newTenantID() string {
|
||||
return fmt.Sprintf("00000000-0000-0000-0000-%012d", time.Now().UnixNano()%1e12)
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 1 + Pruefung 2: Aggregationsjob liefert bei parallelen
|
||||
// Schreibzugriffen konsistente Zaehlerstaende.
|
||||
func TestIncrement_ConsistentUnderConcurrentWrites(t *testing.T) {
|
||||
store, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
tenant := newTenantID()
|
||||
|
||||
const goroutines = 50
|
||||
var wg sync.WaitGroup
|
||||
for i := 0; i < goroutines; i++ {
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
if err := store.Increment(ctx, tenant, "api_calls", 1); err != nil {
|
||||
t.Errorf("increment: %v", err)
|
||||
}
|
||||
}()
|
||||
}
|
||||
wg.Wait()
|
||||
|
||||
value, err := store.Get(ctx, tenant, "api_calls")
|
||||
if err != nil {
|
||||
t.Fatalf("get: %v", err)
|
||||
}
|
||||
if value != goroutines {
|
||||
t.Fatalf("erwartet %d, habe %d (hinweis auf lost update unter nebenlaeufigkeit)", goroutines, value)
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 3 + Pruefung 3: Zaehlerstand eines Tenants beeinflusst
|
||||
// nicht den eines anderen.
|
||||
func TestIncrement_IsolatedBetweenTenants(t *testing.T) {
|
||||
store, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
tenantA, tenantB := newTenantID(), newTenantID()
|
||||
|
||||
if err := store.Increment(ctx, tenantA, "users", 5); err != nil {
|
||||
t.Fatalf("increment a: %v", err)
|
||||
}
|
||||
if err := store.Increment(ctx, tenantB, "users", 1); err != nil {
|
||||
t.Fatalf("increment b: %v", err)
|
||||
}
|
||||
|
||||
valA, err := store.Get(ctx, tenantA, "users")
|
||||
if err != nil {
|
||||
t.Fatalf("get a: %v", err)
|
||||
}
|
||||
valB, err := store.Get(ctx, tenantB, "users")
|
||||
if err != nil {
|
||||
t.Fatalf("get b: %v", err)
|
||||
}
|
||||
if valA != 5 || valB != 1 {
|
||||
t.Fatalf("erwartet a=5 b=1, habe a=%d b=%d", valA, valB)
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 2 + Pruefung 1: Quota-Ueberschreitung wird automatisiert
|
||||
// erkannt und die definierte Reaktion ausgeloest.
|
||||
func TestEnforce_TriggersReactionOnExceeded(t *testing.T) {
|
||||
store, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
tenant := newTenantID()
|
||||
|
||||
if err := store.SetQuota(ctx, tenant, "users", 10); err != nil {
|
||||
t.Fatalf("set quota: %v", err)
|
||||
}
|
||||
if err := store.Increment(ctx, tenant, "users", 11); err != nil {
|
||||
t.Fatalf("increment: %v", err)
|
||||
}
|
||||
|
||||
var reacted bool
|
||||
var gotStatus Status
|
||||
status, err := store.Enforce(ctx, tenant, "users", func(ctx context.Context, tenantID, metric string, value, limit int64, status Status) {
|
||||
reacted = true
|
||||
gotStatus = status
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("enforce: %v", err)
|
||||
}
|
||||
if status != StatusExceeded {
|
||||
t.Fatalf("erwartet StatusExceeded, habe %q", status)
|
||||
}
|
||||
if !reacted || gotStatus != StatusExceeded {
|
||||
t.Fatal("erwartet ausgeloeste reaktion mit StatusExceeded")
|
||||
}
|
||||
}
|
||||
|
||||
func TestCheck_WarningThresholdAndOK(t *testing.T) {
|
||||
store, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
tenant := newTenantID()
|
||||
|
||||
if err := store.SetQuota(ctx, tenant, "storage_mb", 100); err != nil {
|
||||
t.Fatalf("set quota: %v", err)
|
||||
}
|
||||
|
||||
if err := store.Increment(ctx, tenant, "storage_mb", 50); err != nil {
|
||||
t.Fatalf("increment: %v", err)
|
||||
}
|
||||
_, _, status, err := store.Check(ctx, tenant, "storage_mb")
|
||||
if err != nil {
|
||||
t.Fatalf("check: %v", err)
|
||||
}
|
||||
if status != StatusOK {
|
||||
t.Fatalf("bei 50%% erwartet StatusOK, habe %q", status)
|
||||
}
|
||||
|
||||
if err := store.Increment(ctx, tenant, "storage_mb", 35); err != nil { // insgesamt 85%
|
||||
t.Fatalf("increment: %v", err)
|
||||
}
|
||||
_, _, status, err = store.Check(ctx, tenant, "storage_mb")
|
||||
if err != nil {
|
||||
t.Fatalf("check: %v", err)
|
||||
}
|
||||
if status != StatusWarning {
|
||||
t.Fatalf("bei 85%% erwartet StatusWarning, habe %q", status)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCheck_NoQuotaMeansUnlimited(t *testing.T) {
|
||||
store, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
tenant := newTenantID()
|
||||
|
||||
if err := store.Increment(ctx, tenant, "api_calls", 1_000_000); err != nil {
|
||||
t.Fatalf("increment: %v", err)
|
||||
}
|
||||
_, _, status, err := store.Check(ctx, tenant, "api_calls")
|
||||
if err != nil {
|
||||
t.Fatalf("check: %v", err)
|
||||
}
|
||||
if status != StatusOK {
|
||||
t.Fatalf("ohne konfigurierte quota erwartet StatusOK, habe %q", status)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRunPeriodicAggregation_CallsRepeatedly(t *testing.T) {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 120*time.Millisecond)
|
||||
defer cancel()
|
||||
|
||||
var mu sync.Mutex
|
||||
calls := 0
|
||||
RunPeriodicAggregation(ctx, 20*time.Millisecond, func(ctx context.Context) error {
|
||||
mu.Lock()
|
||||
calls++
|
||||
mu.Unlock()
|
||||
return nil
|
||||
})
|
||||
|
||||
mu.Lock()
|
||||
defer mu.Unlock()
|
||||
if calls < 3 {
|
||||
t.Fatalf("erwartet mehrfache aufrufe innerhalb von 120ms bei 20ms interval, habe %d", calls)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
DROP TABLE IF EXISTS audit_events;
|
||||
@@ -0,0 +1,17 @@
|
||||
-- Zentrales Audit-Log-Modell (AUD-01, siehe core-kanban/tickets/AUD-01.md).
|
||||
-- Getrennt vom allgemeinen Anwendungs-Log (Akzeptanzkriterium 2): eigene
|
||||
-- Tabelle, eigenes Paket (internal/audit), kein Log-Framework.
|
||||
-- tenant_slug ist NOT NULL + darf nicht leer sein (Akzeptanzkriterium 2 /
|
||||
-- Pruefung 2) — mandantenuebergreifende Ereignisse nutzen den reservierten
|
||||
-- Wert 'system', niemals NULL oder leeren String.
|
||||
CREATE TABLE audit_events (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
occurred_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
tenant_slug TEXT NOT NULL CHECK (tenant_slug <> ''),
|
||||
actor TEXT NOT NULL CHECK (actor <> ''),
|
||||
action TEXT NOT NULL CHECK (action <> ''),
|
||||
target TEXT NOT NULL,
|
||||
metadata JSONB NOT NULL DEFAULT '{}'::jsonb
|
||||
);
|
||||
|
||||
CREATE INDEX audit_events_tenant_slug_idx ON audit_events (tenant_slug, occurred_at);
|
||||
@@ -0,0 +1 @@
|
||||
DROP TABLE IF EXISTS tenant_licenses;
|
||||
@@ -0,0 +1,12 @@
|
||||
-- Lizenzumfang pro Mandant (LIC-01, siehe core-kanban/tickets/LIC-01.md).
|
||||
-- Genau ein Lizenzdatensatz pro Tenant (tenant_id PK) — ein neues Einspielen
|
||||
-- ersetzt den vorherigen Datensatz vollstaendig statt eine Historie zu fuehren.
|
||||
CREATE TABLE tenant_licenses (
|
||||
tenant_id UUID PRIMARY KEY REFERENCES tenants(id),
|
||||
plan TEXT NOT NULL,
|
||||
modules TEXT[] NOT NULL,
|
||||
issued_at TIMESTAMPTZ NOT NULL,
|
||||
valid_until TIMESTAMPTZ NOT NULL,
|
||||
raw_key TEXT NOT NULL,
|
||||
installed_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
@@ -0,0 +1,2 @@
|
||||
DROP TABLE IF EXISTS usage_quotas;
|
||||
DROP TABLE IF EXISTS usage_counters;
|
||||
@@ -0,0 +1,15 @@
|
||||
-- Nutzungszaehler & Quotas je Tenant (LIC-03, siehe core-kanban/tickets/LIC-03.md).
|
||||
CREATE TABLE usage_counters (
|
||||
tenant_id UUID NOT NULL,
|
||||
metric TEXT NOT NULL,
|
||||
value BIGINT NOT NULL DEFAULT 0,
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
PRIMARY KEY (tenant_id, metric)
|
||||
);
|
||||
|
||||
CREATE TABLE usage_quotas (
|
||||
tenant_id UUID NOT NULL,
|
||||
metric TEXT NOT NULL,
|
||||
limit_value BIGINT NOT NULL,
|
||||
PRIMARY KEY (tenant_id, metric)
|
||||
);
|
||||
@@ -0,0 +1,2 @@
|
||||
DROP TABLE resync_usage_buffer;
|
||||
DROP TABLE resync_audit_buffer;
|
||||
@@ -0,0 +1,22 @@
|
||||
-- Wiederanlauf & Nachsynchronisierung nach Core-Ausfall (API-06, siehe
|
||||
-- core-kanban/tickets/API-06.md) — lokale, PERSISTENTE Pufferqueue (kein
|
||||
-- In-Memory) fuer Audit-Events und Nutzungszaehler-Deltas eines Moduls.
|
||||
CREATE TABLE resync_audit_buffer (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
seq BIGSERIAL,
|
||||
tenant_slug TEXT NOT NULL,
|
||||
actor TEXT NOT NULL,
|
||||
action TEXT NOT NULL,
|
||||
target TEXT NOT NULL DEFAULT '',
|
||||
metadata JSONB NOT NULL DEFAULT '{}',
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE TABLE resync_usage_buffer (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
seq BIGSERIAL,
|
||||
tenant_slug TEXT NOT NULL,
|
||||
metric TEXT NOT NULL,
|
||||
delta BIGINT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
@@ -1,2 +0,0 @@
|
||||
DROP TABLE status_history;
|
||||
DROP TABLE status_targets;
|
||||
@@ -1,15 +0,0 @@
|
||||
-- Zentrale Statusseite (OPS-02, siehe core-kanban/tickets/OPS-02.md) —
|
||||
-- ueberwachte Module und der Verlauf ihrer Statusaenderungen.
|
||||
CREATE TABLE status_targets (
|
||||
name TEXT PRIMARY KEY,
|
||||
health_url TEXT NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE status_history (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
name TEXT NOT NULL,
|
||||
status TEXT NOT NULL,
|
||||
changed_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE INDEX status_history_name_idx ON status_history (name, changed_at DESC);
|
||||
@@ -1,11 +1,24 @@
|
||||
#!/usr/bin/env bash
|
||||
# Setzt die nexarch-Testumgebung zurueck: loescht die geteilte
|
||||
# Registry-Tabelle "tenants" in der postgres-Wartungsdatenbank sowie alle
|
||||
# tenant_*-Datenbanken. Noetig, weil verschiedene Feature-Branches
|
||||
# unterschiedliche Registry-Schemata erwarten, aber dieselbe physische
|
||||
# Postgres-Instanz auf dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
|
||||
#
|
||||
# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/reset-test-env.sh
|
||||
set -euo pipefail
|
||||
|
||||
PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
|
||||
ROLE="nexarch_test"
|
||||
|
||||
export PGPASSWORD="$PASS"
|
||||
|
||||
psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants CASCADE;"
|
||||
psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS audit_events CASCADE;"
|
||||
|
||||
dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
|
||||
for db in $dbs; do
|
||||
psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
|
||||
done
|
||||
|
||||
echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."
|
||||
|
||||
@@ -1,12 +1,24 @@
|
||||
#!/usr/bin/env bash
|
||||
# Ein-Kommando-Pruefung fuer den aktuellen Code-Stand auf dem Testhost:
|
||||
# Registry+Tenant-DBs zuruecksetzen, dann build/vet/test in einem Rutsch.
|
||||
# -p 1 ist Pflicht, da mehrere Pakete dieselbe physische Registry-Tabelle auf
|
||||
# dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
|
||||
#
|
||||
# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/run-checks.sh
|
||||
set -euo pipefail
|
||||
|
||||
PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh
|
||||
|
||||
export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable"
|
||||
|
||||
echo "== go build =="
|
||||
go build ./...
|
||||
|
||||
echo "== go vet =="
|
||||
go vet ./...
|
||||
|
||||
echo "== go test (-p 1) =="
|
||||
go test ./... -p 1 -count=1
|
||||
|
||||
@@ -1,45 +0,0 @@
|
||||
# @nexarch/shl — UI-Shell & Design-System (Core SHL-01)
|
||||
|
||||
Gemeinsames Paket für alle NEXARCH-Modul-Frontends (Core, DMS, Mail, Archive, Workflow, AI, Connect).
|
||||
Ein Modul-Frontend importiert ausschließlich über `index.ts`, kopiert keine Komponenten oder Tokens lokal.
|
||||
|
||||
## Enthält
|
||||
|
||||
- **Design-Tokens** (`tokens/tokens.ts`) — Farbe (Hell/Dunkel), Abstand, Typografie. Kontrastwerte gegen WCAG 2.1 AA geprüft (siehe `__tests__/tokens.test.ts`).
|
||||
- **Theming** (`theme/ThemeProvider.tsx`) — zentrale Hell/Dunkel-Umschaltung, respektiert `prefers-color-scheme`, persistiert in `localStorage`.
|
||||
- **i18n-Rahmen** (`i18n/i18n.tsx`) — Umschaltmechanismus Deutsch/Englisch. Modul-Frontends registrieren ihre fachlichen Textbausteine über `registerMessages()`, statt einen eigenen Mechanismus zu bauen.
|
||||
- **Basis-Komponenten** (`components/`) — `Shell` (Layout + Navigation), `Table`, `Dialog`, `TextField`/`SelectField`/`CheckboxField`, `Toast`. Alle mit WCAG-2.1-AA-Grundlage (Tastaturbedienung, ARIA-Attribute, Fokus-Management).
|
||||
|
||||
## Verwendung in einem Modul-Frontend
|
||||
|
||||
```tsx
|
||||
import { ThemeProvider, I18nProvider, ToastProvider, Shell } from "@nexarch/shl";
|
||||
|
||||
export default function RootLayout({ children }: { children: React.ReactNode }) {
|
||||
return (
|
||||
<ThemeProvider>
|
||||
<I18nProvider initialLocale="de">
|
||||
<ToastProvider>
|
||||
<Shell modules={[]} tenantLabel="Mandant XY">
|
||||
{children}
|
||||
</Shell>
|
||||
</ToastProvider>
|
||||
</I18nProvider>
|
||||
</ThemeProvider>
|
||||
);
|
||||
}
|
||||
```
|
||||
|
||||
## Bekannter offener Punkt
|
||||
|
||||
Die vier bereits gebauten Core-Frontends (`TEN-05`, `LIC-04`, `AUD-04`, `OPS-02`) sind vor diesem Paket entstanden und binden es noch nicht ein — Retrofit ist der nächste Schritt, siehe `nexarch-state.json`.
|
||||
|
||||
## Tests
|
||||
|
||||
Ausführung auf dem Test-Host (nicht lokal, siehe Projekt-Testinfrastruktur):
|
||||
|
||||
```bash
|
||||
npm install
|
||||
npm test
|
||||
npm run typecheck
|
||||
```
|
||||
@@ -1,38 +0,0 @@
|
||||
// Prüfung: Tastaturbedienung der Basis-Komponenten funktioniert (SHL-01 Prüfung 2).
|
||||
import { describe, expect, it, vi } from "vitest";
|
||||
import { fireEvent, render, screen } from "@testing-library/react";
|
||||
import { Dialog } from "../components/Dialog";
|
||||
import { I18nProvider } from "../i18n/i18n";
|
||||
|
||||
function renderDialog(onClose: () => void) {
|
||||
return render(
|
||||
<I18nProvider>
|
||||
<Dialog open titleId="test-title" title="Test-Dialog" onClose={onClose}>
|
||||
<button type="button">Erste Aktion</button>
|
||||
<button type="button">Zweite Aktion</button>
|
||||
</Dialog>
|
||||
</I18nProvider>,
|
||||
);
|
||||
}
|
||||
|
||||
describe("Dialog: Tastaturbedienung", () => {
|
||||
it("schließt sich bei ESC", () => {
|
||||
const onClose = vi.fn();
|
||||
renderDialog(onClose);
|
||||
fireEvent.keyDown(document, { key: "Escape" });
|
||||
expect(onClose).toHaveBeenCalledOnce();
|
||||
});
|
||||
|
||||
it("setzt den Fokus beim Öffnen auf das erste fokussierbare Element", () => {
|
||||
renderDialog(vi.fn());
|
||||
const closeButton = screen.getByRole("button", { name: /schließen/i });
|
||||
expect(document.activeElement).toBe(closeButton);
|
||||
});
|
||||
|
||||
it("ist als modaler Dialog mit Titel-Referenz ausgezeichnet", () => {
|
||||
renderDialog(vi.fn());
|
||||
const dialog = screen.getByRole("dialog");
|
||||
expect(dialog).toHaveAttribute("aria-modal", "true");
|
||||
expect(dialog).toHaveAttribute("aria-labelledby", "test-title");
|
||||
});
|
||||
});
|
||||
@@ -1,39 +0,0 @@
|
||||
// Prüfung: Kontrastwerte erfüllen mindestens AA (SHL-01 Prüfung 3 / Akzeptanzkriterium 4).
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { colorTokens } from "../tokens/tokens";
|
||||
|
||||
// WCAG-2.1-AA-Kontrastberechnung (relative Luminanz, sRGB) — keine externe Abhängigkeit nötig.
|
||||
function relLuminance(hex: string): number {
|
||||
const rgb = [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255);
|
||||
const [r, g, b] = rgb.map((c) => (c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4));
|
||||
return 0.2126 * r + 0.7152 * g + 0.0722 * b;
|
||||
}
|
||||
|
||||
function contrastRatio(a: string, b: string): number {
|
||||
const l1 = relLuminance(a);
|
||||
const l2 = relLuminance(b);
|
||||
const [lighter, darker] = l1 > l2 ? [l1, l2] : [l2, l1];
|
||||
return (lighter + 0.05) / (darker + 0.05);
|
||||
}
|
||||
|
||||
describe("Design-Tokens: WCAG 2.1 AA Kontrast", () => {
|
||||
for (const scheme of ["light", "dark"] as const) {
|
||||
const c = colorTokens[scheme];
|
||||
|
||||
it(`${scheme}: textPrimary auf background erfüllt AA (>= 4.5:1)`, () => {
|
||||
expect(contrastRatio(c.textPrimary, c.background)).toBeGreaterThanOrEqual(4.5);
|
||||
});
|
||||
|
||||
it(`${scheme}: textSecondary auf surface erfüllt AA (>= 4.5:1)`, () => {
|
||||
expect(contrastRatio(c.textSecondary, c.surface)).toBeGreaterThanOrEqual(4.5);
|
||||
});
|
||||
|
||||
it(`${scheme}: accentContrast auf accent erfüllt AA (>= 4.5:1)`, () => {
|
||||
expect(contrastRatio(c.accentContrast, c.accent)).toBeGreaterThanOrEqual(4.5);
|
||||
});
|
||||
|
||||
it(`${scheme}: dangerContrast auf danger erfüllt AA (>= 4.5:1)`, () => {
|
||||
expect(contrastRatio(c.dangerContrast, c.danger)).toBeGreaterThanOrEqual(4.5);
|
||||
});
|
||||
}
|
||||
});
|
||||
@@ -1,88 +0,0 @@
|
||||
"use client";
|
||||
|
||||
// Dialog-Basis-Komponente — SHL-01. WCAG 2.1 AA: Fokus-Falle, ESC schließt, Tastaturbedienung vollständig.
|
||||
|
||||
import { useEffect, useRef } from "react";
|
||||
import type { ReactNode } from "react";
|
||||
import { useI18n } from "../i18n/i18n";
|
||||
|
||||
const FOCUSABLE_SELECTOR =
|
||||
'a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
|
||||
|
||||
export interface DialogProps {
|
||||
open: boolean;
|
||||
onClose: () => void;
|
||||
titleId: string;
|
||||
title: string;
|
||||
children: ReactNode;
|
||||
}
|
||||
|
||||
export function Dialog({ open, onClose, titleId, title, children }: DialogProps) {
|
||||
const { t } = useI18n();
|
||||
const dialogRef = useRef<HTMLDivElement>(null);
|
||||
const previouslyFocused = useRef<HTMLElement | null>(null);
|
||||
|
||||
useEffect(() => {
|
||||
if (!open) return;
|
||||
previouslyFocused.current = document.activeElement as HTMLElement | null;
|
||||
|
||||
const node = dialogRef.current;
|
||||
const focusables = node?.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR);
|
||||
focusables?.[0]?.focus();
|
||||
|
||||
function handleKeyDown(event: KeyboardEvent) {
|
||||
if (event.key === "Escape") {
|
||||
onClose();
|
||||
return;
|
||||
}
|
||||
if (event.key !== "Tab" || !node) return;
|
||||
|
||||
const items = Array.from(node.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR));
|
||||
if (items.length === 0) return;
|
||||
const first = items[0];
|
||||
const last = items[items.length - 1];
|
||||
|
||||
if (event.shiftKey && document.activeElement === first) {
|
||||
event.preventDefault();
|
||||
last.focus();
|
||||
} else if (!event.shiftKey && document.activeElement === last) {
|
||||
event.preventDefault();
|
||||
first.focus();
|
||||
}
|
||||
}
|
||||
|
||||
document.addEventListener("keydown", handleKeyDown);
|
||||
return () => {
|
||||
document.removeEventListener("keydown", handleKeyDown);
|
||||
previouslyFocused.current?.focus();
|
||||
};
|
||||
}, [open, onClose]);
|
||||
|
||||
if (!open) return null;
|
||||
|
||||
return (
|
||||
<div
|
||||
className="shl-dialog-backdrop"
|
||||
role="presentation"
|
||||
onMouseDown={(event) => {
|
||||
if (event.target === event.currentTarget) onClose();
|
||||
}}
|
||||
>
|
||||
<div
|
||||
ref={dialogRef}
|
||||
className="shl-dialog"
|
||||
role="dialog"
|
||||
aria-modal="true"
|
||||
aria-labelledby={titleId}
|
||||
>
|
||||
<div className="shl-dialog-header">
|
||||
<h2 id={titleId}>{title}</h2>
|
||||
<button type="button" onClick={onClose} aria-label={t("shl.dialog.close")}>
|
||||
×
|
||||
</button>
|
||||
</div>
|
||||
<div className="shl-dialog-body">{children}</div>
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -1,98 +0,0 @@
|
||||
// Formularelemente-Basis-Komponenten — SHL-01. WCAG: jedes Feld hat verknüpftes <label>,
|
||||
// Fehler werden per aria-describedby + aria-invalid angebunden, nicht nur farblich markiert.
|
||||
|
||||
import { useId } from "react";
|
||||
import type { InputHTMLAttributes, ReactNode, SelectHTMLAttributes } from "react";
|
||||
|
||||
interface FieldWrapperProps {
|
||||
label: string;
|
||||
error?: string;
|
||||
hint?: string;
|
||||
children: (ids: { inputId: string; describedBy: string | undefined }) => ReactNode;
|
||||
}
|
||||
|
||||
function FieldWrapper({ label, error, hint, children }: FieldWrapperProps) {
|
||||
const inputId = useId();
|
||||
const hintId = hint ? `${inputId}-hint` : undefined;
|
||||
const errorId = error ? `${inputId}-error` : undefined;
|
||||
const describedBy = [hintId, errorId].filter(Boolean).join(" ") || undefined;
|
||||
|
||||
return (
|
||||
<div className="shl-field">
|
||||
<label htmlFor={inputId}>{label}</label>
|
||||
{children({ inputId, describedBy })}
|
||||
{hint && (
|
||||
<p id={hintId} className="shl-field-hint">
|
||||
{hint}
|
||||
</p>
|
||||
)}
|
||||
{error && (
|
||||
<p id={errorId} className="shl-field-error" role="alert">
|
||||
{error}
|
||||
</p>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
export interface TextFieldProps
|
||||
extends Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "aria-describedby"> {
|
||||
label: string;
|
||||
error?: string;
|
||||
hint?: string;
|
||||
}
|
||||
|
||||
export function TextField({ label, error, hint, ...inputProps }: TextFieldProps) {
|
||||
return (
|
||||
<FieldWrapper label={label} error={error} hint={hint}>
|
||||
{({ inputId, describedBy }) => (
|
||||
<input
|
||||
id={inputId}
|
||||
aria-describedby={describedBy}
|
||||
aria-invalid={error ? true : undefined}
|
||||
{...inputProps}
|
||||
/>
|
||||
)}
|
||||
</FieldWrapper>
|
||||
);
|
||||
}
|
||||
|
||||
export interface SelectFieldProps
|
||||
extends Omit<SelectHTMLAttributes<HTMLSelectElement>, "id" | "aria-describedby"> {
|
||||
label: string;
|
||||
error?: string;
|
||||
hint?: string;
|
||||
children: ReactNode;
|
||||
}
|
||||
|
||||
export function SelectField({ label, error, hint, children, ...selectProps }: SelectFieldProps) {
|
||||
return (
|
||||
<FieldWrapper label={label} error={error} hint={hint}>
|
||||
{({ inputId, describedBy }) => (
|
||||
<select
|
||||
id={inputId}
|
||||
aria-describedby={describedBy}
|
||||
aria-invalid={error ? true : undefined}
|
||||
{...selectProps}
|
||||
>
|
||||
{children}
|
||||
</select>
|
||||
)}
|
||||
</FieldWrapper>
|
||||
);
|
||||
}
|
||||
|
||||
export interface CheckboxFieldProps
|
||||
extends Omit<InputHTMLAttributes<HTMLInputElement>, "id" | "type"> {
|
||||
label: string;
|
||||
}
|
||||
|
||||
export function CheckboxField({ label, ...inputProps }: CheckboxFieldProps) {
|
||||
const inputId = useId();
|
||||
return (
|
||||
<div className="shl-field shl-field-checkbox">
|
||||
<input id={inputId} type="checkbox" {...inputProps} />
|
||||
<label htmlFor={inputId}>{label}</label>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -1,62 +0,0 @@
|
||||
"use client";
|
||||
|
||||
// Layout-Shell mit Navigation — SHL-01 Akzeptanzkriterium 1.
|
||||
// Globale Navigation zeigt nur Module, die Core für Tenant/Benutzer freigibt (Backend entscheidet, UI blendet nur aus).
|
||||
|
||||
import type { ReactNode } from "react";
|
||||
import { useI18n } from "../i18n/i18n";
|
||||
import { useTheme } from "../theme/ThemeProvider";
|
||||
|
||||
export interface ModuleLink {
|
||||
key: string;
|
||||
label: string;
|
||||
href: string;
|
||||
active?: boolean;
|
||||
}
|
||||
|
||||
export interface ShellProps {
|
||||
modules: ModuleLink[];
|
||||
tenantLabel: string;
|
||||
children: ReactNode;
|
||||
}
|
||||
|
||||
export function Shell({ modules, tenantLabel, children }: ShellProps) {
|
||||
const { scheme, toggle } = useTheme();
|
||||
const { t } = useI18n();
|
||||
|
||||
return (
|
||||
<div className="shl-shell">
|
||||
<a className="shl-skip-link" href="#shl-main-content">
|
||||
{t("shl.shell.skipToContent", "Zum Inhalt springen")}
|
||||
</a>
|
||||
<header className="shl-shell-header">
|
||||
<nav aria-label={t("shl.shell.moduleNav", "Modul-Navigation")}>
|
||||
<ul>
|
||||
{modules.map((mod) => (
|
||||
<li key={mod.key}>
|
||||
<a href={mod.href} aria-current={mod.active ? "page" : undefined}>
|
||||
{mod.label}
|
||||
</a>
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
</nav>
|
||||
<div className="shl-shell-context">
|
||||
<span className="shl-tenant-context">{tenantLabel}</span>
|
||||
<button
|
||||
type="button"
|
||||
onClick={toggle}
|
||||
aria-label={
|
||||
scheme === "light" ? t("shl.theme.toggleToDark") : t("shl.theme.toggleToLight")
|
||||
}
|
||||
>
|
||||
{scheme === "light" ? "🌙" : "☀️"}
|
||||
</button>
|
||||
</div>
|
||||
</header>
|
||||
<main id="shl-main-content" className="shl-shell-content" tabIndex={-1}>
|
||||
{children}
|
||||
</main>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -1,83 +0,0 @@
|
||||
// Table-Basis-Komponente — SHL-01. WCAG: semantische <table>, scope auf Kopfzellen, sortierbare Spalten per Tastatur.
|
||||
|
||||
import type { ReactNode } from "react";
|
||||
import { useI18n } from "../i18n/i18n";
|
||||
|
||||
export interface TableColumn<Row> {
|
||||
key: string;
|
||||
header: string;
|
||||
render: (row: Row) => ReactNode;
|
||||
sortable?: boolean;
|
||||
}
|
||||
|
||||
export interface TableProps<Row> {
|
||||
columns: TableColumn<Row>[];
|
||||
rows: Row[];
|
||||
rowKey: (row: Row) => string;
|
||||
sortKey?: string;
|
||||
sortDirection?: "asc" | "desc";
|
||||
onSort?: (key: string) => void;
|
||||
caption?: string;
|
||||
}
|
||||
|
||||
export function Table<Row>({
|
||||
columns,
|
||||
rows,
|
||||
rowKey,
|
||||
sortKey,
|
||||
sortDirection,
|
||||
onSort,
|
||||
caption,
|
||||
}: TableProps<Row>) {
|
||||
const { t } = useI18n();
|
||||
|
||||
return (
|
||||
<table className="shl-table">
|
||||
{caption && <caption>{caption}</caption>}
|
||||
<thead>
|
||||
<tr>
|
||||
{columns.map((column) => {
|
||||
const isSorted = column.key === sortKey;
|
||||
const ariaSort = column.sortable
|
||||
? isSorted
|
||||
? sortDirection === "asc"
|
||||
? "ascending"
|
||||
: "descending"
|
||||
: "none"
|
||||
: undefined;
|
||||
return (
|
||||
<th key={column.key} scope="col" aria-sort={ariaSort}>
|
||||
{column.sortable ? (
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => onSort?.(column.key)}
|
||||
className="shl-table-sort-button"
|
||||
>
|
||||
{column.header}
|
||||
</button>
|
||||
) : (
|
||||
column.header
|
||||
)}
|
||||
</th>
|
||||
);
|
||||
})}
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{rows.length === 0 ? (
|
||||
<tr>
|
||||
<td colSpan={columns.length}>{t("shl.table.noRows")}</td>
|
||||
</tr>
|
||||
) : (
|
||||
rows.map((row) => (
|
||||
<tr key={rowKey(row)}>
|
||||
{columns.map((column) => (
|
||||
<td key={column.key}>{column.render(row)}</td>
|
||||
))}
|
||||
</tr>
|
||||
))
|
||||
)}
|
||||
</tbody>
|
||||
</table>
|
||||
);
|
||||
}
|
||||
@@ -1,67 +0,0 @@
|
||||
"use client";
|
||||
|
||||
// Toast-Basis-Komponente — SHL-01. WCAG: aria-live sorgt dafür, dass Screenreader Meldungen ansagen.
|
||||
|
||||
import { createContext, useCallback, useContext, useMemo, useState } from "react";
|
||||
import type { ReactNode } from "react";
|
||||
import { useI18n } from "../i18n/i18n";
|
||||
|
||||
export type ToastVariant = "info" | "success" | "danger" | "warning";
|
||||
|
||||
export interface ToastMessage {
|
||||
id: string;
|
||||
text: string;
|
||||
variant: ToastVariant;
|
||||
}
|
||||
|
||||
interface ToastContextValue {
|
||||
toasts: ToastMessage[];
|
||||
push: (text: string, variant?: ToastVariant) => void;
|
||||
dismiss: (id: string) => void;
|
||||
}
|
||||
|
||||
const ToastContext = createContext<ToastContextValue | null>(null);
|
||||
|
||||
export function ToastProvider({ children }: { children: ReactNode }) {
|
||||
const [toasts, setToasts] = useState<ToastMessage[]>([]);
|
||||
const { t } = useI18n();
|
||||
|
||||
const dismiss = useCallback((id: string) => {
|
||||
setToasts((current) => current.filter((toast) => toast.id !== id));
|
||||
}, []);
|
||||
|
||||
const push = useCallback((text: string, variant: ToastVariant = "info") => {
|
||||
const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
|
||||
setToasts((current) => [...current, { id, text, variant }]);
|
||||
}, []);
|
||||
|
||||
const value = useMemo(() => ({ toasts, push, dismiss }), [toasts, push, dismiss]);
|
||||
|
||||
return (
|
||||
<ToastContext.Provider value={value}>
|
||||
{children}
|
||||
<div className="shl-toast-region" role="status" aria-live="polite" aria-atomic="false">
|
||||
{toasts.map((toast) => (
|
||||
<div key={toast.id} className={`shl-toast shl-toast-${toast.variant}`}>
|
||||
<span>{toast.text}</span>
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => dismiss(toast.id)}
|
||||
aria-label={t("shl.toast.dismiss")}
|
||||
>
|
||||
×
|
||||
</button>
|
||||
</div>
|
||||
))}
|
||||
</div>
|
||||
</ToastContext.Provider>
|
||||
);
|
||||
}
|
||||
|
||||
export function useToast(): ToastContextValue {
|
||||
const ctx = useContext(ToastContext);
|
||||
if (!ctx) {
|
||||
throw new Error("useToast muss innerhalb von <ToastProvider> aufgerufen werden");
|
||||
}
|
||||
return ctx;
|
||||
}
|
||||
@@ -1,75 +0,0 @@
|
||||
"use client";
|
||||
|
||||
// i18n-Rahmen (mind. Deutsch/Englisch) — SHL-01 Akzeptanzkriterium 5.
|
||||
// Liefert nur den Umschaltmechanismus + Basis-Komponenten-Texte.
|
||||
// Modul-Frontends liefern ihre eigenen fachlichen Textbausteine über registerMessages(),
|
||||
// statt einen eigenen i18n-Mechanismus zu bauen (siehe UI-UX-KONZEPT.md Abschnitt 4).
|
||||
|
||||
import { createContext, useContext, useMemo, useState } from "react";
|
||||
import type { ReactNode } from "react";
|
||||
|
||||
export type Locale = "de" | "en";
|
||||
|
||||
type MessageDict = Record<string, string>;
|
||||
type MessageBundle = Record<Locale, MessageDict>;
|
||||
|
||||
const baseMessages: MessageBundle = {
|
||||
de: {
|
||||
"shl.dialog.close": "Schließen",
|
||||
"shl.toast.dismiss": "Meldung schließen",
|
||||
"shl.table.noRows": "Keine Einträge vorhanden",
|
||||
"shl.theme.toggleToLight": "Helles Erscheinungsbild",
|
||||
"shl.theme.toggleToDark": "Dunkles Erscheinungsbild",
|
||||
},
|
||||
en: {
|
||||
"shl.dialog.close": "Close",
|
||||
"shl.toast.dismiss": "Dismiss message",
|
||||
"shl.table.noRows": "No entries",
|
||||
"shl.theme.toggleToLight": "Switch to light theme",
|
||||
"shl.theme.toggleToDark": "Switch to dark theme",
|
||||
},
|
||||
};
|
||||
|
||||
// Registry, in die Modul-Frontends ihre eigenen Textbausteine einhängen.
|
||||
const registry: MessageBundle = { de: { ...baseMessages.de }, en: { ...baseMessages.en } };
|
||||
|
||||
export function registerMessages(locale: Locale, messages: MessageDict): void {
|
||||
registry[locale] = { ...registry[locale], ...messages };
|
||||
}
|
||||
|
||||
interface I18nContextValue {
|
||||
locale: Locale;
|
||||
setLocale: (locale: Locale) => void;
|
||||
t: (key: string, fallback?: string) => string;
|
||||
}
|
||||
|
||||
const I18nContext = createContext<I18nContextValue | null>(null);
|
||||
|
||||
export function I18nProvider({
|
||||
initialLocale = "de",
|
||||
children,
|
||||
}: {
|
||||
initialLocale?: Locale;
|
||||
children: ReactNode;
|
||||
}) {
|
||||
const [locale, setLocale] = useState<Locale>(initialLocale);
|
||||
|
||||
const value = useMemo<I18nContextValue>(
|
||||
() => ({
|
||||
locale,
|
||||
setLocale,
|
||||
t: (key: string, fallback?: string) => registry[locale][key] ?? fallback ?? key,
|
||||
}),
|
||||
[locale],
|
||||
);
|
||||
|
||||
return <I18nContext.Provider value={value}>{children}</I18nContext.Provider>;
|
||||
}
|
||||
|
||||
export function useI18n(): I18nContextValue {
|
||||
const ctx = useContext(I18nContext);
|
||||
if (!ctx) {
|
||||
throw new Error("useI18n muss innerhalb von <I18nProvider> aufgerufen werden");
|
||||
}
|
||||
return ctx;
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
// Öffentliche Schnittstelle des Pakets @nexarch/shl — Modul-Frontends importieren ausschließlich hierüber,
|
||||
// nicht aus internen Unterpfaden (SHL-01 Akzeptanzkriterium 2: dokumentiert, versioniert, importierbar statt kopiert).
|
||||
|
||||
export { colorTokens, spacing, breakpoints, typography, cssVariables } from "./tokens/tokens";
|
||||
export type { ColorScheme, ColorTokens } from "./tokens/tokens";
|
||||
|
||||
export { ThemeProvider, useTheme, currentColors } from "./theme/ThemeProvider";
|
||||
|
||||
export { I18nProvider, useI18n, registerMessages } from "./i18n/i18n";
|
||||
export type { Locale } from "./i18n/i18n";
|
||||
|
||||
export { Shell } from "./components/Shell";
|
||||
export type { ShellProps, ModuleLink } from "./components/Shell";
|
||||
|
||||
export { Dialog } from "./components/Dialog";
|
||||
export type { DialogProps } from "./components/Dialog";
|
||||
|
||||
export { Table } from "./components/Table";
|
||||
export type { TableProps, TableColumn } from "./components/Table";
|
||||
|
||||
export { TextField, SelectField, CheckboxField } from "./components/FormElements";
|
||||
export type { TextFieldProps, SelectFieldProps, CheckboxFieldProps } from "./components/FormElements";
|
||||
|
||||
export { ToastProvider, useToast } from "./components/Toast";
|
||||
export type { ToastMessage, ToastVariant } from "./components/Toast";
|
||||
@@ -1,25 +0,0 @@
|
||||
{
|
||||
"name": "@nexarch/shl",
|
||||
"version": "0.1.0",
|
||||
"private": true,
|
||||
"description": "NEXARCH UI-Shell & Design-System (Core SHL-01) — gemeinsames Paket für alle Modul-Frontends.",
|
||||
"main": "index.ts",
|
||||
"types": "index.ts",
|
||||
"scripts": {
|
||||
"test": "vitest run",
|
||||
"typecheck": "tsc --noEmit"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"react": "^18.3.1",
|
||||
"react-dom": "^18.3.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@testing-library/jest-dom": "^6.4.8",
|
||||
"@testing-library/react": "^16.0.0",
|
||||
"@types/react": "18.3.3",
|
||||
"@types/react-dom": "18.3.0",
|
||||
"jsdom": "^24.1.1",
|
||||
"typescript": "5.5.3",
|
||||
"vitest": "^2.0.0"
|
||||
}
|
||||
}
|
||||
@@ -1,81 +0,0 @@
|
||||
"use client";
|
||||
|
||||
// Zentrales Theming (Hell/Dunkel) — SHL-01 Akzeptanzkriterium 6.
|
||||
// Einzige Quelle für Hell/Dunkel-Werte; Modul-Frontends schalten nur um, bauen kein eigenes Theming.
|
||||
|
||||
import { createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";
|
||||
import type { ReactNode } from "react";
|
||||
import { colorTokens, cssVariables, type ColorScheme } from "../tokens/tokens";
|
||||
|
||||
const STORAGE_KEY = "nexarch-shl-theme";
|
||||
|
||||
interface ThemeContextValue {
|
||||
scheme: ColorScheme;
|
||||
setScheme: (scheme: ColorScheme) => void;
|
||||
toggle: () => void;
|
||||
}
|
||||
|
||||
const ThemeContext = createContext<ThemeContextValue | null>(null);
|
||||
|
||||
function readStoredScheme(): ColorScheme | null {
|
||||
if (typeof window === "undefined") return null;
|
||||
try {
|
||||
const stored = window.localStorage.getItem(STORAGE_KEY);
|
||||
return stored === "light" || stored === "dark" ? stored : null;
|
||||
} catch {
|
||||
// localStorage kann in privaten Fenstern/eingeschränkten Kontexten fehlschlagen — kein Absturz, nur kein persistierter Zustand.
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function systemPrefersDark(): boolean {
|
||||
if (typeof window === "undefined" || !window.matchMedia) return false;
|
||||
return window.matchMedia("(prefers-color-scheme: dark)").matches;
|
||||
}
|
||||
|
||||
export function ThemeProvider({ children }: { children: ReactNode }) {
|
||||
const [scheme, setSchemeState] = useState<ColorScheme>("light");
|
||||
|
||||
useEffect(() => {
|
||||
const stored = readStoredScheme();
|
||||
setSchemeState(stored ?? (systemPrefersDark() ? "dark" : "light"));
|
||||
}, []);
|
||||
|
||||
const setScheme = useCallback((next: ColorScheme) => {
|
||||
setSchemeState(next);
|
||||
try {
|
||||
window.localStorage.setItem(STORAGE_KEY, next);
|
||||
} catch {
|
||||
// Speichern optional — Umschaltung funktioniert auch ohne Persistenz.
|
||||
}
|
||||
}, []);
|
||||
|
||||
const toggle = useCallback(() => {
|
||||
setScheme(scheme === "light" ? "dark" : "light");
|
||||
}, [scheme, setScheme]);
|
||||
|
||||
useEffect(() => {
|
||||
const vars = cssVariables(scheme);
|
||||
const root = document.documentElement;
|
||||
for (const [key, value] of Object.entries(vars)) {
|
||||
root.style.setProperty(key, value);
|
||||
}
|
||||
root.dataset.shlTheme = scheme;
|
||||
}, [scheme]);
|
||||
|
||||
const value = useMemo(() => ({ scheme, setScheme, toggle }), [scheme, setScheme, toggle]);
|
||||
|
||||
return <ThemeContext.Provider value={value}>{children}</ThemeContext.Provider>;
|
||||
}
|
||||
|
||||
export function useTheme(): ThemeContextValue {
|
||||
const ctx = useContext(ThemeContext);
|
||||
if (!ctx) {
|
||||
throw new Error("useTheme muss innerhalb von <ThemeProvider> aufgerufen werden");
|
||||
}
|
||||
return ctx;
|
||||
}
|
||||
|
||||
export function currentColors(scheme: ColorScheme) {
|
||||
return colorTokens[scheme];
|
||||
}
|
||||
@@ -1,96 +0,0 @@
|
||||
// Design-Tokens: einzige Quelle für Farbe, Abstand, Typografie im gesamten Frontend-Verbund.
|
||||
// Modul-Frontends importieren diese Tokens, überschreiben sie nicht lokal (SHL-01 Akzeptanzkriterium 3).
|
||||
// Kontrastwerte sind gegen WCAG 2.1 AA geprüft (Akzeptanzkriterium 1/4): mindestens 4.5:1 für Fließtext.
|
||||
|
||||
export type ColorScheme = "light" | "dark";
|
||||
|
||||
export interface ColorTokens {
|
||||
background: string;
|
||||
surface: string;
|
||||
surfaceRaised: string;
|
||||
border: string;
|
||||
textPrimary: string;
|
||||
textSecondary: string;
|
||||
accent: string;
|
||||
accentContrast: string;
|
||||
danger: string;
|
||||
dangerContrast: string;
|
||||
success: string;
|
||||
warning: string;
|
||||
focusRing: string;
|
||||
}
|
||||
|
||||
// Kontrastwerte geprüft: textPrimary auf background/surface >= 7:1, textSecondary >= 4.5:1,
|
||||
// accentContrast auf accent >= 4.5:1 (WCAG AA, siehe SHL-01 Prüfung 3).
|
||||
export const colorTokens: Record<ColorScheme, ColorTokens> = {
|
||||
light: {
|
||||
background: "#FFFFFF",
|
||||
surface: "#F5F6F8",
|
||||
surfaceRaised: "#FFFFFF",
|
||||
border: "#D7DBE0",
|
||||
textPrimary: "#14181F",
|
||||
textSecondary: "#4B5563",
|
||||
accent: "#1D4ED8",
|
||||
accentContrast: "#FFFFFF",
|
||||
danger: "#B91C1C",
|
||||
dangerContrast: "#FFFFFF",
|
||||
success: "#15803D",
|
||||
warning: "#B45309",
|
||||
focusRing: "#1D4ED8",
|
||||
},
|
||||
dark: {
|
||||
background: "#0F1115",
|
||||
surface: "#181B21",
|
||||
surfaceRaised: "#20242C",
|
||||
border: "#333944",
|
||||
textPrimary: "#F2F4F7",
|
||||
textSecondary: "#B4BAC4",
|
||||
accent: "#5B8DEF",
|
||||
accentContrast: "#0F1115",
|
||||
danger: "#F87171",
|
||||
dangerContrast: "#0F1115",
|
||||
success: "#4ADE80",
|
||||
warning: "#FBBF24",
|
||||
focusRing: "#5B8DEF",
|
||||
},
|
||||
};
|
||||
|
||||
export const spacing = {
|
||||
xs: "4px",
|
||||
sm: "8px",
|
||||
md: "16px",
|
||||
lg: "24px",
|
||||
xl: "32px",
|
||||
xxl: "48px",
|
||||
} as const;
|
||||
|
||||
export const breakpoints = {
|
||||
mobile: "0px",
|
||||
tablet: "768px",
|
||||
desktop: "1200px",
|
||||
} as const;
|
||||
|
||||
export const typography = {
|
||||
fontFamily: "'Inter', 'Segoe UI', system-ui, sans-serif",
|
||||
fontFamilyMono: "'JetBrains Mono', ui-monospace, monospace",
|
||||
sizeSm: "13px",
|
||||
sizeMd: "15px",
|
||||
sizeLg: "18px",
|
||||
sizeXl: "24px",
|
||||
lineHeight: 1.5,
|
||||
weightRegular: 400,
|
||||
weightMedium: 500,
|
||||
weightBold: 600,
|
||||
} as const;
|
||||
|
||||
export function cssVariables(scheme: ColorScheme): Record<string, string> {
|
||||
const c = colorTokens[scheme];
|
||||
const vars: Record<string, string> = {};
|
||||
for (const [key, value] of Object.entries(c)) {
|
||||
vars[`--shl-color-${key.replace(/([A-Z])/g, "-$1").toLowerCase()}`] = value;
|
||||
}
|
||||
for (const [key, value] of Object.entries(spacing)) {
|
||||
vars[`--shl-spacing-${key}`] = value;
|
||||
}
|
||||
return vars;
|
||||
}
|
||||
@@ -1,18 +0,0 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"target": "ES2020",
|
||||
"lib": ["dom", "dom.iterable", "esnext"],
|
||||
"jsx": "react-jsx",
|
||||
"module": "ESNext",
|
||||
"moduleResolution": "bundler",
|
||||
"strict": true,
|
||||
"declaration": true,
|
||||
"esModuleInterop": true,
|
||||
"skipLibCheck": true,
|
||||
"forceConsistentCasingInFileNames": true,
|
||||
"noUnusedLocals": true,
|
||||
"noUnusedParameters": true
|
||||
},
|
||||
"include": ["**/*.ts", "**/*.tsx"],
|
||||
"exclude": ["node_modules"]
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
import { defineConfig } from "vitest/config";
|
||||
|
||||
export default defineConfig({
|
||||
test: {
|
||||
environment: "jsdom",
|
||||
setupFiles: ["./vitest.setup.ts"],
|
||||
},
|
||||
});
|
||||
@@ -1,9 +0,0 @@
|
||||
import "@testing-library/jest-dom/vitest";
|
||||
import { afterEach } from "vitest";
|
||||
import { cleanup } from "@testing-library/react";
|
||||
|
||||
// Ohne explizites Cleanup bleiben zwischen den it()-Blöcken gerenderte Dialoge im DOM stehen
|
||||
// (mehrere <html>/<body>-Bäume stapeln sich), wodurch getByRole() mehrere Treffer statt einen findet.
|
||||
afterEach(() => {
|
||||
cleanup();
|
||||
});
|
||||
@@ -1,30 +0,0 @@
|
||||
import { ThemeProvider, I18nProvider, ToastProvider, typography } from "@nexarch/shl";
|
||||
|
||||
export const metadata = {
|
||||
title: "NEXARCH Systemstatus",
|
||||
};
|
||||
|
||||
export default function RootLayout({
|
||||
children,
|
||||
}: {
|
||||
children: React.ReactNode;
|
||||
}) {
|
||||
return (
|
||||
<html lang="de">
|
||||
<body
|
||||
style={{
|
||||
fontFamily: typography.fontFamily,
|
||||
margin: 0,
|
||||
background: "var(--shl-color-background, #ffffff)",
|
||||
color: "var(--shl-color-text-primary, #14181f)",
|
||||
}}
|
||||
>
|
||||
<ThemeProvider>
|
||||
<I18nProvider initialLocale="de">
|
||||
<ToastProvider>{children}</ToastProvider>
|
||||
</I18nProvider>
|
||||
</ThemeProvider>
|
||||
</body>
|
||||
</html>
|
||||
);
|
||||
}
|
||||
@@ -1,125 +0,0 @@
|
||||
"use client";
|
||||
|
||||
import { useEffect, useState } from "react";
|
||||
import { fetchOverview, fetchHistory, type ModuleStatus, type HistoryEntry } from "@/lib/api";
|
||||
|
||||
const POLL_INTERVAL_MS = 5000;
|
||||
|
||||
export default function Page() {
|
||||
const [modules, setModules] = useState<ModuleStatus[]>([]);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const [selected, setSelected] = useState<string | null>(null);
|
||||
const [history, setHistory] = useState<HistoryEntry[] | null>(null);
|
||||
const [historyError, setHistoryError] = useState<string | null>(null);
|
||||
|
||||
useEffect(() => {
|
||||
let cancelled = false;
|
||||
|
||||
async function poll() {
|
||||
try {
|
||||
const data = await fetchOverview();
|
||||
if (!cancelled) {
|
||||
setModules(data);
|
||||
setError(null);
|
||||
}
|
||||
} catch (e: any) {
|
||||
// Ein nicht antwortendes Backend darf die zuletzt bekannte Ansicht
|
||||
// nicht loeschen und die Seite nicht unbedienbar machen
|
||||
// (Akzeptanzkriterium 2) — nur eine Fehlermeldung anzeigen, alte
|
||||
// Daten bleiben sichtbar.
|
||||
if (!cancelled) {
|
||||
setError(e.message ?? "Unbekannter Fehler beim Laden der Uebersicht");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
poll();
|
||||
const id = setInterval(poll, POLL_INTERVAL_MS);
|
||||
return () => {
|
||||
cancelled = true;
|
||||
clearInterval(id);
|
||||
};
|
||||
}, []);
|
||||
|
||||
async function openHistory(name: string) {
|
||||
setSelected(name);
|
||||
setHistoryError(null);
|
||||
try {
|
||||
const data = await fetchHistory(name);
|
||||
setHistory(data);
|
||||
} catch (e: any) {
|
||||
setHistoryError(e.message ?? "Verlauf konnte nicht geladen werden");
|
||||
setHistory(null);
|
||||
}
|
||||
}
|
||||
|
||||
const anyDown = modules.some((m) => m.status === "down");
|
||||
|
||||
return (
|
||||
<main style={{ maxWidth: 800, margin: "0 auto", padding: "2rem 1rem" }}>
|
||||
<h1>Systemstatus</h1>
|
||||
|
||||
{error && (
|
||||
<p style={{ color: "#c62828", background: "#fdecea", padding: "0.5rem", borderRadius: 4 }} role="alert">
|
||||
Uebersicht konnte gerade nicht aktualisiert werden: {error}. Zuletzt bekannter Stand wird weiter angezeigt.
|
||||
</p>
|
||||
)}
|
||||
|
||||
{!error && anyDown && (
|
||||
<p style={{ color: "#c62828", background: "#fdecea", padding: "0.5rem", borderRadius: 4 }}>
|
||||
Mindestens ein Modul ist derzeit nicht erreichbar.
|
||||
</p>
|
||||
)}
|
||||
|
||||
<ul style={{ listStyle: "none", padding: 0 }}>
|
||||
{modules.map((m) => (
|
||||
<li
|
||||
key={m.name}
|
||||
style={{
|
||||
display: "flex",
|
||||
justifyContent: "space-between",
|
||||
alignItems: "center",
|
||||
background: "white",
|
||||
padding: "0.75rem 1rem",
|
||||
marginBottom: "0.5rem",
|
||||
borderRadius: 8,
|
||||
borderLeft: `6px solid ${m.status === "up" ? "#2e7d32" : "#c62828"}`,
|
||||
}}
|
||||
>
|
||||
<div>
|
||||
<strong>{m.name}</strong>
|
||||
<div style={{ fontSize: "0.85rem", color: "#666" }}>
|
||||
{m.status === "up" ? "Verfügbar" : "Nicht verfügbar"}
|
||||
{m.last_checked && ` — zuletzt geprüft ${new Date(m.last_checked).toLocaleString("de-DE")}`}
|
||||
</div>
|
||||
</div>
|
||||
<button onClick={() => openHistory(m.name)}>Verlauf</button>
|
||||
</li>
|
||||
))}
|
||||
{modules.length === 0 && !error && <li>Lade Modulstatus…</li>}
|
||||
</ul>
|
||||
|
||||
{selected && (
|
||||
<section style={{ background: "white", padding: "1rem", borderRadius: 8, marginTop: "1.5rem" }}>
|
||||
<h2>Verlauf: {selected}</h2>
|
||||
{historyError && (
|
||||
<p style={{ color: "#c62828" }} role="alert">
|
||||
{historyError}
|
||||
</p>
|
||||
)}
|
||||
{history && (
|
||||
<ul>
|
||||
{history.map((h, i) => (
|
||||
<li key={i}>
|
||||
{new Date(h.changed_at).toLocaleString("de-DE")} — {h.status === "up" ? "verfügbar" : "nicht verfügbar"}
|
||||
</li>
|
||||
))}
|
||||
{history.length === 0 && <li>Keine Statusänderungen bisher.</li>}
|
||||
</ul>
|
||||
)}
|
||||
<button onClick={() => setSelected(null)}>Schließen</button>
|
||||
</section>
|
||||
)}
|
||||
</main>
|
||||
);
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
// Duenner Client des OPS-02-Backends (internal/statuspage) — keine eigene
|
||||
// Aggregations-/Polling-Logik im Frontend.
|
||||
export type ModuleStatus = {
|
||||
name: string;
|
||||
status: "up" | "down";
|
||||
last_checked?: string;
|
||||
};
|
||||
|
||||
export type HistoryEntry = {
|
||||
status: "up" | "down";
|
||||
changed_at: string;
|
||||
};
|
||||
|
||||
function apiBase(): string {
|
||||
const base = process.env.NEXT_PUBLIC_STATUSPAGE_API_URL;
|
||||
if (!base) {
|
||||
throw new Error(
|
||||
"NEXT_PUBLIC_STATUSPAGE_API_URL ist nicht gesetzt (Umgebungsvariable erforderlich)"
|
||||
);
|
||||
}
|
||||
return base;
|
||||
}
|
||||
|
||||
// fetchOverview holt den Status EINES Moduls unabhaengig vom Erfolg der
|
||||
// anderen — ein Netzwerkfehler beim Abruf der Gesamtuebersicht wird vom
|
||||
// Aufrufer (Page-Komponente) abgefangen, sodass ein nicht antwortendes
|
||||
// Backend die Seite nicht zum Absturz bringt (Akzeptanzkriterium 2).
|
||||
export async function fetchOverview(): Promise<ModuleStatus[]> {
|
||||
const res = await fetch(`${apiBase()}/status/overview`, { cache: "no-store" });
|
||||
if (!res.ok) {
|
||||
throw new Error(`Uebersicht konnte nicht geladen werden (${res.status})`);
|
||||
}
|
||||
return res.json();
|
||||
}
|
||||
|
||||
export async function fetchHistory(name: string): Promise<HistoryEntry[]> {
|
||||
const res = await fetch(`${apiBase()}/status/history?name=${encodeURIComponent(name)}`, {
|
||||
cache: "no-store",
|
||||
});
|
||||
if (!res.ok) {
|
||||
throw new Error(`Verlauf konnte nicht geladen werden (${res.status})`);
|
||||
}
|
||||
return res.json();
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
/** @type {import('next').NextConfig} */
|
||||
const nextConfig = {
|
||||
// @nexarch/shl liegt als file:-Dependency mit TS-Quellen in node_modules —
|
||||
// Next.js transpiliert node_modules standardmäßig nicht, siehe web/shl/README.md.
|
||||
transpilePackages: ["@nexarch/shl"],
|
||||
};
|
||||
export default nextConfig;
|
||||
@@ -1,22 +0,0 @@
|
||||
{
|
||||
"name": "nexarch-status-page",
|
||||
"private": true,
|
||||
"scripts": {
|
||||
"dev": "next dev",
|
||||
"build": "next build",
|
||||
"start": "next start",
|
||||
"lint": "next lint"
|
||||
},
|
||||
"dependencies": {
|
||||
"@nexarch/shl": "file:../shl",
|
||||
"next": "14.2.35",
|
||||
"react": "18.3.1",
|
||||
"react-dom": "18.3.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "20.14.9",
|
||||
"@types/react": "18.3.3",
|
||||
"@types/react-dom": "18.3.0",
|
||||
"typescript": "5.5.3"
|
||||
}
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"target": "es2017",
|
||||
"lib": ["dom", "dom.iterable", "esnext"],
|
||||
"allowJs": true,
|
||||
"skipLibCheck": true,
|
||||
"strict": true,
|
||||
"noEmit": true,
|
||||
"esModuleInterop": true,
|
||||
"module": "esnext",
|
||||
"moduleResolution": "bundler",
|
||||
"resolveJsonModule": true,
|
||||
"isolatedModules": true,
|
||||
"jsx": "preserve",
|
||||
"incremental": true,
|
||||
"plugins": [{ "name": "next" }],
|
||||
"paths": { "@/*": ["./*"] }
|
||||
},
|
||||
"include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
|
||||
"exclude": ["node_modules"]
|
||||
}
|
||||
Reference in New Issue
Block a user