Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 sysops
|
1e8a6c22cd | ||
|
sysops
|
46fccd9c09 | ||
|
sysops
|
a631ac8770 | ||
|
sysops
|
bc2126f3b1 | ||
|
sysopsandClaude Sonnet 5
|
b23cd1961f | ||
|
sysopsandClaude Sonnet 5
|
4a30345e07 | ||
|
sysopsandClaude Sonnet 5
|
8da9c67d08 |
@@ -44,3 +44,88 @@ Keine Commits in dieser Session.
|
|||||||
Keine Änderungen ermittelbar.
|
Keine Änderungen ermittelbar.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
## 2026-08-27 17:26 – 17:28 (1m)
|
||||||
|
**Beschreibung:** Claude Code Session
|
||||||
|
**Projekt:** code
|
||||||
|
|
||||||
|
### Commits
|
||||||
|
- c895a67 core: initial Go module skeleton (config, db pool, tenant registry migration)
|
||||||
|
|
||||||
|
### Geänderte Dateien
|
||||||
|
- .gitignore | 2 ++
|
||||||
|
- DEVLOG.md | 46 ++++++++++++++++++++++++++++++++++++++++++++++
|
||||||
|
- cmd/core/main.go | 33 +++++++++++++++++++++++++++++++++
|
||||||
|
- go.mod | 5 +++++
|
||||||
|
- internal/config/config.go | 29 +++++++++++++++++++++++++++++
|
||||||
|
- internal/db/db.go | 11 +++++++++++
|
||||||
|
- migrations/0001_tenant_registry.sql | 10 ++++++++++
|
||||||
|
|
||||||
|
---
|
||||||
|
## 2026-08-27 17:28 – 17:29 (1m)
|
||||||
|
**Beschreibung:** Claude Code Session
|
||||||
|
**Projekt:** code
|
||||||
|
|
||||||
|
### Commits
|
||||||
|
Keine Commits in dieser Session.
|
||||||
|
|
||||||
|
### Geänderte Dateien
|
||||||
|
- .gitignore | 2 ++
|
||||||
|
- DEVLOG.md | 46 ++++++++++++++++++++++++++++++++++++++++++++++
|
||||||
|
- cmd/core/main.go | 33 +++++++++++++++++++++++++++++++++
|
||||||
|
- go.mod | 5 +++++
|
||||||
|
- internal/config/config.go | 29 +++++++++++++++++++++++++++++
|
||||||
|
- internal/db/db.go | 11 +++++++++++
|
||||||
|
- migrations/0001_tenant_registry.sql | 10 ++++++++++
|
||||||
|
|
||||||
|
---
|
||||||
|
## 2026-08-27 17:31 – 17:31 (0m)
|
||||||
|
**Beschreibung:** Claude Code Session
|
||||||
|
**Projekt:** code
|
||||||
|
|
||||||
|
### Commits
|
||||||
|
Keine Commits in dieser Session.
|
||||||
|
|
||||||
|
### Geänderte Dateien
|
||||||
|
- .gitignore | 2 ++
|
||||||
|
- DEVLOG.md | 46 ++++++++++++++++++++++++++++++++++++++++++++++
|
||||||
|
- cmd/core/main.go | 33 +++++++++++++++++++++++++++++++++
|
||||||
|
- go.mod | 5 +++++
|
||||||
|
- internal/config/config.go | 29 +++++++++++++++++++++++++++++
|
||||||
|
- internal/db/db.go | 11 +++++++++++
|
||||||
|
- migrations/0001_tenant_registry.sql | 10 ++++++++++
|
||||||
|
|
||||||
|
---
|
||||||
|
## 2026-08-27 17:36 – 17:36 (0m)
|
||||||
|
**Beschreibung:** Claude Code Session
|
||||||
|
**Projekt:** code
|
||||||
|
|
||||||
|
### Commits
|
||||||
|
Keine Commits in dieser Session.
|
||||||
|
|
||||||
|
### Geänderte Dateien
|
||||||
|
- .gitignore | 2 ++
|
||||||
|
- DEVLOG.md | 46 ++++++++++++++++++++++++++++++++++++++++++++++
|
||||||
|
- cmd/core/main.go | 33 +++++++++++++++++++++++++++++++++
|
||||||
|
- go.mod | 5 +++++
|
||||||
|
- internal/config/config.go | 29 +++++++++++++++++++++++++++++
|
||||||
|
- internal/db/db.go | 11 +++++++++++
|
||||||
|
- migrations/0001_tenant_registry.sql | 10 ++++++++++
|
||||||
|
|
||||||
|
---
|
||||||
|
## 2026-08-27 17:36 – 17:37 (0m)
|
||||||
|
**Beschreibung:** Claude Code Session
|
||||||
|
**Projekt:** code
|
||||||
|
|
||||||
|
### Commits
|
||||||
|
Keine Commits in dieser Session.
|
||||||
|
|
||||||
|
### Geänderte Dateien
|
||||||
|
- .gitignore | 2 ++
|
||||||
|
- DEVLOG.md | 46 ++++++++++++++++++++++++++++++++++++++++++++++
|
||||||
|
- cmd/core/main.go | 33 +++++++++++++++++++++++++++++++++
|
||||||
|
- go.mod | 5 +++++
|
||||||
|
- internal/config/config.go | 29 +++++++++++++++++++++++++++++
|
||||||
|
- internal/db/db.go | 11 +++++++++++
|
||||||
|
- migrations/0001_tenant_registry.sql | 10 ++++++++++
|
||||||
|
|
||||||
|
---
|
||||||
|
|||||||
+18
-3
@@ -7,6 +7,7 @@ import (
|
|||||||
|
|
||||||
"gitea.perlbach24.de/scripte/nexarch/internal/config"
|
"gitea.perlbach24.de/scripte/nexarch/internal/config"
|
||||||
"gitea.perlbach24.de/scripte/nexarch/internal/db"
|
"gitea.perlbach24.de/scripte/nexarch/internal/db"
|
||||||
|
"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
|
||||||
)
|
)
|
||||||
|
|
||||||
func main() {
|
func main() {
|
||||||
@@ -15,16 +16,30 @@ func main() {
|
|||||||
log.Fatalf("config: %v", err)
|
log.Fatalf("config: %v", err)
|
||||||
}
|
}
|
||||||
|
|
||||||
pool, err := db.Connect(context.Background(), cfg.RegistryDSN)
|
ctx := context.Background()
|
||||||
|
|
||||||
|
registryPool, err := db.Connect(ctx, cfg.RegistryDSN)
|
||||||
if err != nil {
|
if err != nil {
|
||||||
log.Fatalf("db: %v", err)
|
log.Fatalf("registry db: %v", err)
|
||||||
}
|
}
|
||||||
defer pool.Close()
|
defer registryPool.Close()
|
||||||
|
|
||||||
|
adminPool, err := db.Connect(ctx, cfg.AdminDSN)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatalf("admin db: %v", err)
|
||||||
|
}
|
||||||
|
defer adminPool.Close()
|
||||||
|
|
||||||
|
registry := tenant.NewRegistry(registryPool)
|
||||||
|
provisioner := tenant.NewProvisioner(adminPool, registry, cfg.TenantDSNTemplate)
|
||||||
|
tenantHandler := tenant.NewHandler(provisioner)
|
||||||
|
|
||||||
mux := http.NewServeMux()
|
mux := http.NewServeMux()
|
||||||
mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
|
mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
|
||||||
w.WriteHeader(http.StatusOK)
|
w.WriteHeader(http.StatusOK)
|
||||||
})
|
})
|
||||||
|
// Vorlaeufiger Pfad ohne Versionierung/Auth — wird mit API-01/IAM-01 abgeloest.
|
||||||
|
mux.HandleFunc("/internal/tenants", tenantHandler.CreateTenant)
|
||||||
|
|
||||||
log.Printf("nexarch-core listening on %s", cfg.ListenAddr)
|
log.Printf("nexarch-core listening on %s", cfg.ListenAddr)
|
||||||
if err := http.ListenAndServe(cfg.ListenAddr, mux); err != nil {
|
if err := http.ListenAndServe(cfg.ListenAddr, mux); err != nil {
|
||||||
|
|||||||
@@ -0,0 +1,82 @@
|
|||||||
|
// kek-api ist der Aufrufpunkt fuer API-12: startet den bereits fertigen
|
||||||
|
// API-10-Handler (internal/kek) als eigenstaendigen HTTP-Dienst.
|
||||||
|
// REINES WIRING — keine Aenderung an internal/kek/, internal/moduleregistry/
|
||||||
|
// oder internal/tenant/.
|
||||||
|
package main
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"log"
|
||||||
|
"net/http"
|
||||||
|
"os"
|
||||||
|
"time"
|
||||||
|
|
||||||
|
"github.com/jackc/pgx/v5/pgxpool"
|
||||||
|
|
||||||
|
"gitea.perlbach24.de/scripte/nexarch/internal/flag"
|
||||||
|
"gitea.perlbach24.de/scripte/nexarch/internal/kek"
|
||||||
|
"gitea.perlbach24.de/scripte/nexarch/internal/moduleregistry"
|
||||||
|
"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
|
||||||
|
)
|
||||||
|
|
||||||
|
// tenantResolverAdapter erfüllt kek.TenantResolver über den bestehenden
|
||||||
|
// tenant.Registry.GetBySlug-Zugriff — kein neuer Tenant-Code, nur
|
||||||
|
// Signatur-Anpassung.
|
||||||
|
type tenantResolverAdapter struct{ registry *tenant.Registry }
|
||||||
|
|
||||||
|
func (a tenantResolverAdapter) ResolveTenantID(ctx context.Context, tenantSlug string) (string, error) {
|
||||||
|
t, err := a.registry.GetBySlug(ctx, tenantSlug)
|
||||||
|
if err != nil {
|
||||||
|
return "", err
|
||||||
|
}
|
||||||
|
return t.ID, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func requireEnv(name string) string {
|
||||||
|
v := os.Getenv(name)
|
||||||
|
if v == "" {
|
||||||
|
log.Fatalf("%s muss gesetzt sein", name)
|
||||||
|
}
|
||||||
|
return v
|
||||||
|
}
|
||||||
|
|
||||||
|
func main() {
|
||||||
|
registryDSN := requireEnv("NEXARCH_KEK_REGISTRY_DSN")
|
||||||
|
masterKeyEnvVar := os.Getenv("NEXARCH_KEK_MASTER_KEY_ENV")
|
||||||
|
if masterKeyEnvVar == "" {
|
||||||
|
masterKeyEnvVar = "NEXARCH_KEK_MASTER_KEY"
|
||||||
|
}
|
||||||
|
addr := os.Getenv("NEXARCH_KEK_API_LISTEN_ADDR")
|
||||||
|
if addr == "" {
|
||||||
|
addr = "127.0.0.1:8102"
|
||||||
|
}
|
||||||
|
|
||||||
|
masterKey, err := kek.LoadMasterKeyFromEnv(masterKeyEnvVar)
|
||||||
|
if err != nil {
|
||||||
|
log.Fatalf("master-key laden: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
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)
|
||||||
|
tenantRegistry := tenant.NewRegistry(pool)
|
||||||
|
store := kek.NewStore(pool)
|
||||||
|
|
||||||
|
handler := kek.NewHandler(store, masterKey, registry, registry, tenantResolverAdapter{registry: tenantRegistry})
|
||||||
|
|
||||||
|
mux := http.NewServeMux()
|
||||||
|
mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) })
|
||||||
|
mux.HandleFunc("/internal/kek/tenant", handler.TenantKEKHandler)
|
||||||
|
|
||||||
|
log.Printf("kek-api: listening on %s", addr)
|
||||||
|
if err := http.ListenAndServe(addr, mux); err != nil {
|
||||||
|
log.Fatalf("http server: %v", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,14 @@
|
|||||||
|
[Unit]
|
||||||
|
Description=NEXARCH Core - KEK-Bezugsdienst (API-10/API-12)
|
||||||
|
After=network.target postgresql.service
|
||||||
|
|
||||||
|
[Service]
|
||||||
|
Type=simple
|
||||||
|
User=nexarch
|
||||||
|
EnvironmentFile=/etc/nexarch/kek-api.env
|
||||||
|
ExecStart=__INSTALL_DIR__/bin/kek-api
|
||||||
|
Restart=on-failure
|
||||||
|
StandardOutput=journal
|
||||||
|
|
||||||
|
[Install]
|
||||||
|
WantedBy=multi-user.target
|
||||||
@@ -0,0 +1,61 @@
|
|||||||
|
# API-12 – Prüfprotokoll: KEK-Bezugsdienst starten (API-10 als laufender Dienst)
|
||||||
|
|
||||||
|
Voraussetzung API-10 – bereits Fertig, hier UNVERÄNDERT.
|
||||||
|
|
||||||
|
## Reines Wiring, keine neue Logik
|
||||||
|
|
||||||
|
`git diff --stat internal/kek/ internal/moduleregistry/ internal/tenant/`
|
||||||
|
liefert KEINEN Diff. `cmd/kek-api/main.go` setzt ausschließlich
|
||||||
|
bestehende Konstruktoren zusammen; `tenantResolverAdapter` bildet nur
|
||||||
|
`tenant.Registry.GetBySlug` auf `kek.TenantResolver` ab (Signatur-
|
||||||
|
Anpassung, kein neuer Fachcode).
|
||||||
|
|
||||||
|
## Umsetzung
|
||||||
|
|
||||||
|
- `cmd/kek-api/main.go` – `POST /internal/kek/tenant?tenant=<slug>`,
|
||||||
|
authentifiziert über dasselbe Service-Credential-Verfahren wie jeder
|
||||||
|
andere Modul-Core-Aufruf (API-02), zusätzlich Tenant-Aktivierungs-
|
||||||
|
prüfung (identisches Muster wie in `internal/kek.Handler` bereits
|
||||||
|
vorgesehen).
|
||||||
|
- `deploy/systemd/nexarch-kek-api.service.tmpl`.
|
||||||
|
|
||||||
|
## Prüfungen
|
||||||
|
|
||||||
|
| # | Prüfung | Ergebnis |
|
||||||
|
|---|---|---|
|
||||||
|
| 1 | Dienst startet und bleibt stabil (systemctl status aktiv) | **bestanden** – real auf 131: `nexarch-kek-api.service` aktiv |
|
||||||
|
| 2 | Realer Aufruf mit gültigem Service-Credential liefert den erwarteten Tenant-KEK, ohne/mit falschem Credential wird abgelehnt | **bestanden** – real per `curl`: echtes Modul registriert+provisioniert, echter Tenant-KEK über `kek.Store.CreateForTenant` erzeugt (Klartext-Hex zum Vergleich notiert) — Aufruf mit korrektem Credential liefert exakt denselben KEK (Base64-dekodiert übereinstimmend mit dem erzeugten Hex-Wert verifiziert); Aufruf mit falschem Credential → 403 |
|
||||||
|
| 3 | Code-Review: keine Änderung an internal/kek/ selbst, nur main.go+systemd neu | **bestanden** – `git diff --stat` bestätigt: `internal/kek/`, `internal/moduleregistry/`, `internal/tenant/` unverändert |
|
||||||
|
|
||||||
|
## Echte Verdrahtung auf 192.168.1.131
|
||||||
|
|
||||||
|
- `kek-api` gebaut nach `/opt/nexarch-core/bin/`,
|
||||||
|
`/etc/nexarch/kek-api.env` (0600, echter zufälliger 32-Byte-
|
||||||
|
Master-Key), Dienst installiert/aktiviert.
|
||||||
|
- Reale Grant-Lücke gefunden und behoben (gleiches Muster wie zuvor):
|
||||||
|
`nexarch_core` hatte keine Rechte auf `tenant_keks` — `GRANT`
|
||||||
|
nachgezogen und über `information_schema.role_table_grants`
|
||||||
|
verifiziert.
|
||||||
|
- End-zu-Ende-Beweis: echtes Modul registriert, Service-Credential
|
||||||
|
provisioniert, echter Tenant + Tenant-KEK real erzeugt, `curl` gegen
|
||||||
|
den laufenden Dienst liefert exakt diesen KEK zurück (Byte-für-Byte
|
||||||
|
verglichen), falsches Credential real abgelehnt. Testdaten
|
||||||
|
anschließend entfernt.
|
||||||
|
|
||||||
|
## Build/Test-Ergebnis (192.168.1.131)
|
||||||
|
|
||||||
|
```
|
||||||
|
go build ./... -> clean
|
||||||
|
go vet ./... -> clean
|
||||||
|
golangci-lint run ./cmd/kek-api/... -> 0 issues
|
||||||
|
```
|
||||||
|
|
||||||
|
Keine neuen Go-Tests nötig (kein neuer Fachcode außer main.go/Adapter,
|
||||||
|
die eigentliche Logik ist bereits durch API-10s eigene Tests
|
||||||
|
abgedeckt).
|
||||||
|
|
||||||
|
## Gesamtergebnis
|
||||||
|
|
||||||
|
**Bestanden.** API-10 ist jetzt ein real laufender, über systemd
|
||||||
|
verwalteter Dienst — Voraussetzung für Mail ARC-02 und künftig DMS
|
||||||
|
FDN-09-Nachnutzung.
|
||||||
@@ -3,3 +3,12 @@ module gitea.perlbach24.de/scripte/nexarch
|
|||||||
go 1.22
|
go 1.22
|
||||||
|
|
||||||
require github.com/jackc/pgx/v5 v5.6.0
|
require github.com/jackc/pgx/v5 v5.6.0
|
||||||
|
|
||||||
|
require (
|
||||||
|
github.com/jackc/pgpassfile v1.0.0 // indirect
|
||||||
|
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
|
||||||
|
github.com/jackc/puddle/v2 v2.2.1 // indirect
|
||||||
|
golang.org/x/crypto v0.17.0 // indirect
|
||||||
|
golang.org/x/sync v0.1.0 // indirect
|
||||||
|
golang.org/x/text v0.14.0 // indirect
|
||||||
|
)
|
||||||
|
|||||||
@@ -0,0 +1,28 @@
|
|||||||
|
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/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=
|
||||||
|
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
|
||||||
|
github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
|
||||||
|
github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
|
||||||
|
github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
|
||||||
|
github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
|
||||||
|
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
|
||||||
|
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
|
||||||
|
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
|
||||||
|
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
|
||||||
|
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
|
||||||
|
github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
|
||||||
|
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
|
||||||
|
golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k=
|
||||||
|
golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4=
|
||||||
|
golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
|
||||||
|
golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
|
||||||
|
golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
|
||||||
|
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
|
||||||
|
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
|
||||||
|
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||||
|
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
|
||||||
|
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
|
||||||
@@ -11,7 +11,14 @@ import (
|
|||||||
// multi_tenancy: Modell C (physisch getrennte DB pro Mandant).
|
// multi_tenancy: Modell C (physisch getrennte DB pro Mandant).
|
||||||
type Config struct {
|
type Config struct {
|
||||||
ListenAddr string
|
ListenAddr string
|
||||||
|
// RegistryDSN verbindet zur Control-Plane-Registry-Datenbank.
|
||||||
RegistryDSN string
|
RegistryDSN string
|
||||||
|
// AdminDSN verbindet zur Wartungsdatenbank (z.B. "postgres") und wird nur
|
||||||
|
// fuer CREATE/DROP DATABASE beim Tenant-Provisioning verwendet.
|
||||||
|
AdminDSN string
|
||||||
|
// TenantDSNTemplate enthaelt genau ein "%s" als Platzhalter fuer den
|
||||||
|
// Datenbanknamen einer neu provisionierten Tenant-Datenbank.
|
||||||
|
TenantDSNTemplate string
|
||||||
}
|
}
|
||||||
|
|
||||||
func Load() (Config, error) {
|
func Load() (Config, error) {
|
||||||
@@ -20,10 +27,25 @@ func Load() (Config, error) {
|
|||||||
return Config{}, fmt.Errorf("NEXARCH_REGISTRY_DSN not set")
|
return Config{}, fmt.Errorf("NEXARCH_REGISTRY_DSN not set")
|
||||||
}
|
}
|
||||||
|
|
||||||
|
adminDSN := os.Getenv("NEXARCH_ADMIN_DSN")
|
||||||
|
if adminDSN == "" {
|
||||||
|
return Config{}, fmt.Errorf("NEXARCH_ADMIN_DSN not set")
|
||||||
|
}
|
||||||
|
|
||||||
|
dsnTemplate := os.Getenv("NEXARCH_TENANT_DSN_TEMPLATE")
|
||||||
|
if dsnTemplate == "" {
|
||||||
|
return Config{}, fmt.Errorf("NEXARCH_TENANT_DSN_TEMPLATE not set")
|
||||||
|
}
|
||||||
|
|
||||||
addr := os.Getenv("NEXARCH_LISTEN_ADDR")
|
addr := os.Getenv("NEXARCH_LISTEN_ADDR")
|
||||||
if addr == "" {
|
if addr == "" {
|
||||||
addr = ":8080"
|
addr = ":8080"
|
||||||
}
|
}
|
||||||
|
|
||||||
return Config{ListenAddr: addr, RegistryDSN: dsn}, nil
|
return Config{
|
||||||
|
ListenAddr: addr,
|
||||||
|
RegistryDSN: dsn,
|
||||||
|
AdminDSN: adminDSN,
|
||||||
|
TenantDSNTemplate: dsnTemplate,
|
||||||
|
}, nil
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -0,0 +1,87 @@
|
|||||||
|
// Package flag implementiert Core LIC-02: einen Feature-Flag-Dienst mit
|
||||||
|
// Strategien (global an/aus, Prozentsatz, Tenant-Zielgruppe) als Kernfunktion
|
||||||
|
// des Core-Dienstes selbst — keine zusaetzliche Infrastruktur (Unleash-Server
|
||||||
|
// + eigene DB), siehe "bewusst vermeiden" im LIC-02-Ticket.
|
||||||
|
package flag
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
"hash/fnv"
|
||||||
|
|
||||||
|
"github.com/jackc/pgx/v5"
|
||||||
|
"github.com/jackc/pgx/v5/pgxpool"
|
||||||
|
)
|
||||||
|
|
||||||
|
var ErrNotFound = errors.New("flag: nicht gefunden")
|
||||||
|
|
||||||
|
// Flag ist die zentrale Definition — Auswertung (Evaluate) ist bewusst davon
|
||||||
|
// getrennt (Unleash-Prinzip: Flag-Verwaltung vs. Flag-Auswertung).
|
||||||
|
type Flag struct {
|
||||||
|
Key string
|
||||||
|
Enabled bool
|
||||||
|
RolloutPercentage int
|
||||||
|
TargetTenantSlugs []string
|
||||||
|
}
|
||||||
|
|
||||||
|
// Store ist die Verwaltungsseite (Admin): Flags definieren/lesen.
|
||||||
|
type Store struct {
|
||||||
|
pool *pgxpool.Pool
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewStore(pool *pgxpool.Pool) *Store {
|
||||||
|
return &Store{pool: pool}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Store) Set(ctx context.Context, f Flag) error {
|
||||||
|
if f.TargetTenantSlugs == nil {
|
||||||
|
f.TargetTenantSlugs = []string{} // pgx uebertraegt ein nil-Slice sonst als SQL NULL statt leerem Array.
|
||||||
|
}
|
||||||
|
_, err := s.pool.Exec(ctx, `
|
||||||
|
INSERT INTO feature_flags (key, enabled, rollout_percentage, target_tenant_slugs, updated_at)
|
||||||
|
VALUES ($1, $2, $3, $4, now())
|
||||||
|
ON CONFLICT (key) DO UPDATE SET
|
||||||
|
enabled = $2, rollout_percentage = $3, target_tenant_slugs = $4, updated_at = now()
|
||||||
|
`, f.Key, f.Enabled, f.RolloutPercentage, f.TargetTenantSlugs)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("flag speichern: %w", err)
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Store) Get(ctx context.Context, key string) (Flag, error) {
|
||||||
|
var f Flag
|
||||||
|
row := s.pool.QueryRow(ctx, `
|
||||||
|
SELECT key, enabled, rollout_percentage, target_tenant_slugs
|
||||||
|
FROM feature_flags WHERE key = $1
|
||||||
|
`, key)
|
||||||
|
if err := row.Scan(&f.Key, &f.Enabled, &f.RolloutPercentage, &f.TargetTenantSlugs); err != nil {
|
||||||
|
if errors.Is(err, pgx.ErrNoRows) {
|
||||||
|
return Flag{}, ErrNotFound
|
||||||
|
}
|
||||||
|
return Flag{}, fmt.Errorf("flag lesen: %w", err)
|
||||||
|
}
|
||||||
|
return f, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// evaluate wendet die Strategien in fester Reihenfolge an: globaler
|
||||||
|
// An/Aus-Schalter zuerst, dann Tenant-Zielgruppe, dann Prozentsatz-Rollout.
|
||||||
|
// Ein unbekannter/nicht getroffener Fall ergibt false — Fail-Safe-Default,
|
||||||
|
// kein Feature wird versehentlich aktiv.
|
||||||
|
func evaluate(f Flag, tenantSlug string) bool {
|
||||||
|
if f.Enabled {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
for _, target := range f.TargetTenantSlugs {
|
||||||
|
if target == tenantSlug {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if f.RolloutPercentage > 0 {
|
||||||
|
h := fnv.New32a()
|
||||||
|
_, _ = h.Write([]byte(f.Key + "|" + tenantSlug))
|
||||||
|
return int(h.Sum32()%100) < f.RolloutPercentage
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
@@ -0,0 +1,43 @@
|
|||||||
|
package flag
|
||||||
|
|
||||||
|
import "testing"
|
||||||
|
|
||||||
|
func TestEvaluate_GlobalEnabled(t *testing.T) {
|
||||||
|
f := Flag{Key: "k", Enabled: true}
|
||||||
|
if !evaluate(f, "irgendein-tenant") {
|
||||||
|
t.Fatal("global aktiviertes flag sollte fuer jeden tenant true liefern")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Akzeptanzkriterium 1 + Pruefung 2: Zielgruppen-Strategie.
|
||||||
|
func TestEvaluate_TargetTenantStrategy(t *testing.T) {
|
||||||
|
f := Flag{Key: "k", Enabled: false, TargetTenantSlugs: []string{"acme"}}
|
||||||
|
if !evaluate(f, "acme") {
|
||||||
|
t.Fatal("erwartet true fuer tenant in zielgruppe")
|
||||||
|
}
|
||||||
|
if evaluate(f, "globex") {
|
||||||
|
t.Fatal("erwartet false fuer tenant ausserhalb der zielgruppe")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestEvaluate_RolloutPercentageBoundaries(t *testing.T) {
|
||||||
|
full := Flag{Key: "k", RolloutPercentage: 100}
|
||||||
|
if !evaluate(full, "beliebiger-tenant-1") || !evaluate(full, "beliebiger-tenant-2") {
|
||||||
|
t.Fatal("100% rollout sollte immer true liefern")
|
||||||
|
}
|
||||||
|
|
||||||
|
none := Flag{Key: "k", RolloutPercentage: 0}
|
||||||
|
if evaluate(none, "beliebiger-tenant") {
|
||||||
|
t.Fatal("0% rollout ohne enabled/zielgruppe sollte false liefern")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestEvaluate_RolloutIsDeterministicPerTenant(t *testing.T) {
|
||||||
|
f := Flag{Key: "k", RolloutPercentage: 50}
|
||||||
|
first := evaluate(f, "stabiler-tenant")
|
||||||
|
for i := 0; i < 5; i++ {
|
||||||
|
if evaluate(f, "stabiler-tenant") != first {
|
||||||
|
t.Fatal("rollout-auswertung sollte fuer denselben tenant/key stabil sein")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,87 @@
|
|||||||
|
package flag
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"log/slog"
|
||||||
|
"sync"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
// DefaultCacheTTL ist die dokumentierte Cache-Invalidierungszeit
|
||||||
|
// (Akzeptanzkriterium 2/3): eine Aenderung wirkt spaetestens nach dieser
|
||||||
|
// Zeit auf allen Core-Instanzen, ohne dass ein Dienst neu gestartet werden
|
||||||
|
// muss (Akzeptanzkriterium 3).
|
||||||
|
const DefaultCacheTTL = 5 * time.Second
|
||||||
|
|
||||||
|
type cacheEntry struct {
|
||||||
|
flag Flag
|
||||||
|
expiresAt time.Time
|
||||||
|
}
|
||||||
|
|
||||||
|
// Service ist die Auswertungsseite (SDK/Client-Analogon zu Unleash) mit
|
||||||
|
// lokalem TTL-Cache. Bewusst getrennt von Store (Verwaltung).
|
||||||
|
type Service struct {
|
||||||
|
store *Store
|
||||||
|
ttl time.Duration
|
||||||
|
|
||||||
|
mu sync.RWMutex
|
||||||
|
cache map[string]cacheEntry
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewService(store *Store, ttl time.Duration) *Service {
|
||||||
|
if ttl <= 0 {
|
||||||
|
ttl = DefaultCacheTTL
|
||||||
|
}
|
||||||
|
return &Service{store: store, ttl: ttl, cache: make(map[string]cacheEntry)}
|
||||||
|
}
|
||||||
|
|
||||||
|
// IsEnabled wertet ein Flag fuer einen Tenant aus. Liefert IMMER einen
|
||||||
|
// bool ohne Fehlerwert — ein nicht erreichbarer Flag-Dienst darf abhaengige
|
||||||
|
// Aufrufer nicht zum Absturz bringen oder zu Fehlerbehandlungscode zwingen,
|
||||||
|
// der leicht vergessen wird (Akzeptanzkriterium 3 / Pruefung 3: dokumentiertes
|
||||||
|
// Fallback-Verhalten = false, ggf. aus dem zuletzt bekannten Zwischenspeicher).
|
||||||
|
func (s *Service) IsEnabled(ctx context.Context, tenantSlug, key string) bool {
|
||||||
|
f, ok := s.resolve(ctx, key)
|
||||||
|
if !ok {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
return evaluate(f, tenantSlug)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Service) resolve(ctx context.Context, key string) (Flag, bool) {
|
||||||
|
s.mu.RLock()
|
||||||
|
entry, exists := s.cache[key]
|
||||||
|
fresh := exists && time.Now().Before(entry.expiresAt)
|
||||||
|
s.mu.RUnlock()
|
||||||
|
if fresh {
|
||||||
|
return entry.flag, true
|
||||||
|
}
|
||||||
|
|
||||||
|
f, err := s.store.Get(ctx, key)
|
||||||
|
if err != nil {
|
||||||
|
if exists {
|
||||||
|
slog.Warn("feature-flag-dienst nicht erreichbar, nutze zwischengespeicherten stand",
|
||||||
|
"flag_key", key, "error", err)
|
||||||
|
return entry.flag, true
|
||||||
|
}
|
||||||
|
slog.Warn("feature-flag-dienst nicht erreichbar, kein zwischengespeicherter stand vorhanden, fallback: deaktiviert",
|
||||||
|
"flag_key", key, "error", err)
|
||||||
|
return Flag{}, false
|
||||||
|
}
|
||||||
|
|
||||||
|
s.mu.Lock()
|
||||||
|
s.cache[key] = cacheEntry{flag: f, expiresAt: time.Now().Add(s.ttl)}
|
||||||
|
s.mu.Unlock()
|
||||||
|
return f, true
|
||||||
|
}
|
||||||
|
|
||||||
|
// Invalidate erzwingt beim naechsten IsEnabled-Aufruf ein sofortiges Neuladen
|
||||||
|
// aus der Datenbank statt auf den TTL-Ablauf zu warten — wird nach Store.Set
|
||||||
|
// auf derselben Instanz aufgerufen, damit der Schreiber die eigene Aenderung
|
||||||
|
// ohne Wartezeit sieht. Andere Core-Instanzen sehen sie spaetestens nach
|
||||||
|
// DefaultCacheTTL (siehe Akzeptanzkriterium 3).
|
||||||
|
func (s *Service) Invalidate(key string) {
|
||||||
|
s.mu.Lock()
|
||||||
|
delete(s.cache, key)
|
||||||
|
s.mu.Unlock()
|
||||||
|
}
|
||||||
@@ -0,0 +1,179 @@
|
|||||||
|
package flag
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"os"
|
||||||
|
"testing"
|
||||||
|
"time"
|
||||||
|
|
||||||
|
"github.com/jackc/pgx/v5/pgxpool"
|
||||||
|
)
|
||||||
|
|
||||||
|
func setupFlagStoreTest(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 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()
|
||||||
|
)`); err != nil {
|
||||||
|
t.Fatalf("schema: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
cleanup := func() {
|
||||||
|
_, _ = pool.Exec(ctx, `DELETE FROM feature_flags WHERE key LIKE 'test\_%' ESCAPE '\'`)
|
||||||
|
pool.Close()
|
||||||
|
}
|
||||||
|
return NewStore(pool), cleanup
|
||||||
|
}
|
||||||
|
|
||||||
|
// Akzeptanzkriterium 1 + Pruefung 2: Zielgruppen-Strategie liefert im Test
|
||||||
|
// die erwartete Auswertung.
|
||||||
|
func TestService_TargetTenantStrategy(t *testing.T) {
|
||||||
|
store, cleanup := setupFlagStoreTest(t)
|
||||||
|
defer cleanup()
|
||||||
|
ctx := context.Background()
|
||||||
|
|
||||||
|
if err := store.Set(ctx, Flag{Key: "test_target_flag", TargetTenantSlugs: []string{"acme"}}); err != nil {
|
||||||
|
t.Fatalf("set: %v", err)
|
||||||
|
}
|
||||||
|
svc := NewService(store, time.Hour)
|
||||||
|
|
||||||
|
if !svc.IsEnabled(ctx, "acme", "test_target_flag") {
|
||||||
|
t.Fatal("erwartet true fuer tenant in zielgruppe")
|
||||||
|
}
|
||||||
|
if svc.IsEnabled(ctx, "globex", "test_target_flag") {
|
||||||
|
t.Fatal("erwartet false fuer tenant ausserhalb der zielgruppe")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Akzeptanzkriterium 2 + 3 + Pruefung 1: Flag-Aenderung wirkt innerhalb der
|
||||||
|
// dokumentierten Cache-Invalidierungszeit, automatisiert gemessen.
|
||||||
|
func TestService_CacheInvalidationTiming(t *testing.T) {
|
||||||
|
store, cleanup := setupFlagStoreTest(t)
|
||||||
|
defer cleanup()
|
||||||
|
ctx := context.Background()
|
||||||
|
|
||||||
|
const ttl = 150 * time.Millisecond
|
||||||
|
if err := store.Set(ctx, Flag{Key: "test_ttl_flag", Enabled: false}); err != nil {
|
||||||
|
t.Fatalf("set: %v", err)
|
||||||
|
}
|
||||||
|
svc := NewService(store, ttl)
|
||||||
|
|
||||||
|
if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
|
||||||
|
t.Fatal("erwartet false vor der aenderung")
|
||||||
|
}
|
||||||
|
|
||||||
|
// Aenderung "auf einer anderen instanz" simulieren: direkt ueber den
|
||||||
|
// Store, ohne svc.Invalidate aufzurufen.
|
||||||
|
changedAt := time.Now()
|
||||||
|
if err := store.Set(ctx, Flag{Key: "test_ttl_flag", Enabled: true}); err != nil {
|
||||||
|
t.Fatalf("set: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Sofort danach sollte der Cache noch den alten Stand liefern.
|
||||||
|
if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
|
||||||
|
t.Fatal("cache haette den alten (false) stand liefern sollen, direkt nach der aenderung")
|
||||||
|
}
|
||||||
|
|
||||||
|
deadline := changedAt.Add(ttl + 100*time.Millisecond)
|
||||||
|
for time.Now().Before(deadline) {
|
||||||
|
if svc.IsEnabled(ctx, "acme", "test_ttl_flag") {
|
||||||
|
elapsed := time.Since(changedAt)
|
||||||
|
t.Logf("aenderung wurde nach %s wirksam (ziel: innerhalb %s + toleranz)", elapsed, ttl)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
time.Sleep(10 * time.Millisecond)
|
||||||
|
}
|
||||||
|
t.Fatalf("aenderung wurde nicht innerhalb von %s wirksam", deadline.Sub(changedAt))
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestService_InvalidateForcesImmediateRefresh(t *testing.T) {
|
||||||
|
store, cleanup := setupFlagStoreTest(t)
|
||||||
|
defer cleanup()
|
||||||
|
ctx := context.Background()
|
||||||
|
|
||||||
|
if err := store.Set(ctx, Flag{Key: "test_invalidate_flag", Enabled: false}); err != nil {
|
||||||
|
t.Fatalf("set: %v", err)
|
||||||
|
}
|
||||||
|
svc := NewService(store, time.Hour) // lange TTL, damit Invalidate den unterschied macht
|
||||||
|
_ = svc.IsEnabled(ctx, "acme", "test_invalidate_flag")
|
||||||
|
|
||||||
|
if err := store.Set(ctx, Flag{Key: "test_invalidate_flag", Enabled: true}); err != nil {
|
||||||
|
t.Fatalf("set: %v", err)
|
||||||
|
}
|
||||||
|
svc.Invalidate("test_invalidate_flag")
|
||||||
|
|
||||||
|
if !svc.IsEnabled(ctx, "acme", "test_invalidate_flag") {
|
||||||
|
t.Fatal("erwartet sofort sichtbaren neuen stand nach Invalidate")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Akzeptanzkriterium 3 + Pruefung 3: Ausfall des Flag-Dienstes fuehrt zu
|
||||||
|
// dokumentiertem Fallback-Verhalten, nicht zum Absturz.
|
||||||
|
func TestService_FallsBackOnStoreFailure(t *testing.T) {
|
||||||
|
store, cleanup := setupFlagStoreTest(t)
|
||||||
|
defer cleanup()
|
||||||
|
ctx := context.Background()
|
||||||
|
|
||||||
|
if err := store.Set(ctx, Flag{Key: "test_fallback_flag", Enabled: true}); err != nil {
|
||||||
|
t.Fatalf("set: %v", err)
|
||||||
|
}
|
||||||
|
svc := NewService(store, time.Hour)
|
||||||
|
|
||||||
|
// Cache vorwaermen, waehrend die DB noch erreichbar ist.
|
||||||
|
if !svc.IsEnabled(ctx, "acme", "test_fallback_flag") {
|
||||||
|
t.Fatal("erwartet true bei funktionierender db")
|
||||||
|
}
|
||||||
|
|
||||||
|
brokenPool, err := pgxpool.New(ctx, "postgresql://nonexistent-host-fuer-test:5432/x?connect_timeout=1")
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("broken pool erstellen (sollte nicht sofort verbinden): %v", err)
|
||||||
|
}
|
||||||
|
brokenStore := NewStore(brokenPool)
|
||||||
|
|
||||||
|
svcWithCache := NewService(brokenStore, time.Nanosecond) // TTL sofort abgelaufen, erzwingt reload-versuch
|
||||||
|
svcWithCache.mu.Lock()
|
||||||
|
svcWithCache.cache["test_fallback_flag"] = cacheEntry{
|
||||||
|
flag: Flag{Key: "test_fallback_flag", Enabled: true},
|
||||||
|
expiresAt: time.Now().Add(-time.Hour), // bereits abgelaufen
|
||||||
|
}
|
||||||
|
svcWithCache.mu.Unlock()
|
||||||
|
|
||||||
|
func() {
|
||||||
|
defer func() {
|
||||||
|
if r := recover(); r != nil {
|
||||||
|
t.Fatalf("IsEnabled hat gepanict statt einen fallback zu liefern: %v", r)
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
if !svcWithCache.IsEnabled(ctx, "acme", "test_fallback_flag") {
|
||||||
|
t.Fatal("erwartet fallback auf zwischengespeicherten (true) stand bei db-ausfall")
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
|
||||||
|
// Voellig frischer Dienst ohne jeglichen cache + kaputte db -> sicherer
|
||||||
|
// default false, kein absturz.
|
||||||
|
freshSvc := NewService(brokenStore, time.Hour)
|
||||||
|
func() {
|
||||||
|
defer func() {
|
||||||
|
if r := recover(); r != nil {
|
||||||
|
t.Fatalf("IsEnabled hat gepanict: %v", r)
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
if freshSvc.IsEnabled(ctx, "acme", "test_fallback_flag") {
|
||||||
|
t.Fatal("erwartet fail-safe false ohne cache und mit kaputter db")
|
||||||
|
}
|
||||||
|
}()
|
||||||
|
}
|
||||||
@@ -0,0 +1,113 @@
|
|||||||
|
package kek
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"encoding/base64"
|
||||||
|
"encoding/json"
|
||||||
|
"errors"
|
||||||
|
"net/http"
|
||||||
|
)
|
||||||
|
|
||||||
|
// 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)
|
||||||
|
}
|
||||||
|
|
||||||
|
// ModuleActivationChecker ist die schmale Schnittstelle zu API-02s
|
||||||
|
// Aktivierungspruefung (internal/moduleregistry.Registry.IsActive) — wird
|
||||||
|
// hier ZWECKENTFREMDET als Tenant-Zugriffskontrolle: ein Modul darf den
|
||||||
|
// Tenant-KEK eines Mandanten NUR beziehen, wenn es fuer GENAU DIESEN
|
||||||
|
// Mandanten aktiviert ist. Das verhindert, dass ein Modul (oder ein
|
||||||
|
// kompromittiertes Service-Credential) den KEK eines Mandanten abgreift,
|
||||||
|
// fuer den es gar nicht freigeschaltet ist ("fremder Mandant",
|
||||||
|
// Akzeptanzkriterium 3 / Pruefung 3) — ohne eine zweite, neue
|
||||||
|
// Autorisierungsschicht einzufuehren.
|
||||||
|
type ModuleActivationChecker interface {
|
||||||
|
IsActive(ctx context.Context, tenantSlug, moduleName string) (bool, error)
|
||||||
|
}
|
||||||
|
|
||||||
|
// TenantResolver loest einen Tenant-Slug in seine interne ID auf
|
||||||
|
// (internal/tenant.Registry.GetBySlug, TEN-01).
|
||||||
|
type TenantResolver interface {
|
||||||
|
ResolveTenantID(ctx context.Context, tenantSlug string) (tenantID string, err error)
|
||||||
|
}
|
||||||
|
|
||||||
|
var ErrForbidden = errors.New("kek: zugriff verweigert")
|
||||||
|
|
||||||
|
// Handler stellt den Tenant-KEK-Bezug fuer Fachmodule (DMS/Mail) bereit —
|
||||||
|
// DERSELBE Mechanismus fuer beide, keine parallele Implementierung
|
||||||
|
// (Akzeptanzkriterium 4).
|
||||||
|
type Handler struct {
|
||||||
|
store *Store
|
||||||
|
masterKey MasterKey
|
||||||
|
auth CredentialAuthenticator
|
||||||
|
activation ModuleActivationChecker
|
||||||
|
tenants TenantResolver
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewHandler(store *Store, masterKey MasterKey, auth CredentialAuthenticator, activation ModuleActivationChecker, tenants TenantResolver) *Handler {
|
||||||
|
return &Handler{store: store, masterKey: masterKey, auth: auth, activation: activation, tenants: tenants}
|
||||||
|
}
|
||||||
|
|
||||||
|
// resolveModuleForTenant authentifiziert den Aufrufer UND prueft, dass das
|
||||||
|
// authentifizierte Modul fuer den angefragten Tenant aktiv ist — beide
|
||||||
|
// Bedingungen muessen erfuellt sein, sonst ErrForbidden
|
||||||
|
// (Akzeptanzkriterium 3 / Pruefung 3).
|
||||||
|
func (h *Handler) resolveModuleForTenant(ctx context.Context, clientID, secret, tenantSlug string) error {
|
||||||
|
moduleName, ok, err := h.auth.Authenticate(ctx, clientID, secret)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
if !ok {
|
||||||
|
return ErrForbidden
|
||||||
|
}
|
||||||
|
active, err := h.activation.IsActive(ctx, tenantSlug, moduleName)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
if !active {
|
||||||
|
return ErrForbidden
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
type tenantKEKResponse struct {
|
||||||
|
TenantKEKBase64 string `json:"tenant_kek_base64"`
|
||||||
|
}
|
||||||
|
|
||||||
|
// TenantKEKHandler liefert den entschluesselten Tenant-KEK EINES Mandanten
|
||||||
|
// an ein berechtigtes, authentifiziertes Modul (Akzeptanzkriterium 4).
|
||||||
|
func (h *Handler) TenantKEKHandler(w http.ResponseWriter, r *http.Request) {
|
||||||
|
clientID := r.Header.Get("X-Nexarch-Client-Id")
|
||||||
|
secret := r.Header.Get("X-Nexarch-Client-Secret")
|
||||||
|
tenantSlug := r.URL.Query().Get("tenant")
|
||||||
|
if tenantSlug == "" {
|
||||||
|
http.Error(w, "tenant-parameter fehlt", http.StatusBadRequest)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := h.resolveModuleForTenant(r.Context(), clientID, secret, tenantSlug); err != nil {
|
||||||
|
if errors.Is(err, ErrForbidden) {
|
||||||
|
http.Error(w, "zugriff auf diesen mandanten verweigert", http.StatusForbidden)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
http.Error(w, "interner fehler", http.StatusInternalServerError)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
tenantID, err := h.tenants.ResolveTenantID(r.Context(), tenantSlug)
|
||||||
|
if err != nil {
|
||||||
|
http.Error(w, "mandant nicht gefunden", http.StatusNotFound)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
plainKEK, err := h.store.GetDecrypted(r.Context(), tenantID, h.masterKey)
|
||||||
|
if err != nil {
|
||||||
|
http.Error(w, "tenant-kek konnte nicht ermittelt werden", http.StatusInternalServerError)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
w.Header().Set("Content-Type", "application/json")
|
||||||
|
_ = json.NewEncoder(w).Encode(tenantKEKResponse{TenantKEKBase64: base64.StdEncoding.EncodeToString(plainKEK)})
|
||||||
|
}
|
||||||
@@ -0,0 +1,350 @@
|
|||||||
|
package kek
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"context"
|
||||||
|
"encoding/base64"
|
||||||
|
"fmt"
|
||||||
|
"net/http"
|
||||||
|
"net/http/httptest"
|
||||||
|
"os"
|
||||||
|
"strings"
|
||||||
|
"testing"
|
||||||
|
"time"
|
||||||
|
|
||||||
|
"github.com/jackc/pgx/v5/pgxpool"
|
||||||
|
|
||||||
|
"gitea.perlbach24.de/scripte/nexarch/internal/flag"
|
||||||
|
"gitea.perlbach24.de/scripte/nexarch/internal/moduleregistry"
|
||||||
|
"gitea.perlbach24.de/scripte/nexarch/internal/tenant"
|
||||||
|
)
|
||||||
|
|
||||||
|
func setupTest(t *testing.T) (*Store, *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 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_keks (
|
||||||
|
tenant_id UUID PRIMARY KEY REFERENCES tenants(id), wrapped_kek BYTEA NOT NULL,
|
||||||
|
created_at TIMESTAMPTZ NOT NULL DEFAULT now(), rotated_at TIMESTAMPTZ
|
||||||
|
);
|
||||||
|
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 NewStore(pool), pool, cleanup
|
||||||
|
}
|
||||||
|
|
||||||
|
func newMasterKey(t *testing.T) MasterKey {
|
||||||
|
t.Helper()
|
||||||
|
key, err := generateRandomKey()
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("masterkey erzeugen: %v", err)
|
||||||
|
}
|
||||||
|
return MasterKey(key)
|
||||||
|
}
|
||||||
|
|
||||||
|
func createTenant(t *testing.T, pool *pgxpool.Pool, slug string) string {
|
||||||
|
t.Helper()
|
||||||
|
var id string
|
||||||
|
err := pool.QueryRow(context.Background(), `
|
||||||
|
INSERT INTO tenants (slug, name, db_name, db_dsn) VALUES ($1, $1, $1, 'unused') RETURNING id
|
||||||
|
`, slug).Scan(&id)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("tenant anlegen: %v", err)
|
||||||
|
}
|
||||||
|
return id
|
||||||
|
}
|
||||||
|
|
||||||
|
func uniqueSlug(prefix string) string {
|
||||||
|
return fmt.Sprintf("%s_%d", prefix, time.Now().UnixNano())
|
||||||
|
}
|
||||||
|
|
||||||
|
// Akzeptanzkriterium 1: LoadMasterKeyFromEnv liest ausschliesslich aus der
|
||||||
|
// Umgebungsvariable, niemals aus Code/DB.
|
||||||
|
func TestLoadMasterKeyFromEnv(t *testing.T) {
|
||||||
|
const envVar = "NEXARCH_TEST_MASTER_KEY_API10"
|
||||||
|
t.Cleanup(func() { os.Unsetenv(envVar) })
|
||||||
|
|
||||||
|
if _, err := LoadMasterKeyFromEnv(envVar); err == nil {
|
||||||
|
t.Fatal("erwartet fehler, wenn umgebungsvariable nicht gesetzt ist")
|
||||||
|
}
|
||||||
|
|
||||||
|
os.Setenv(envVar, "zu-kurz")
|
||||||
|
if _, err := LoadMasterKeyFromEnv(envVar); err == nil {
|
||||||
|
t.Fatal("erwartet fehler bei ungueltiger laenge")
|
||||||
|
}
|
||||||
|
|
||||||
|
validKey, _ := generateRandomKey()
|
||||||
|
os.Setenv(envVar, base64.StdEncoding.EncodeToString(validKey))
|
||||||
|
loaded, err := LoadMasterKeyFromEnv(envVar)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("laden mit gueltigem key: %v", err)
|
||||||
|
}
|
||||||
|
if !bytes.Equal(loaded, validKey) {
|
||||||
|
t.Fatal("geladener master-key stimmt nicht mit dem gesetzten ueberein")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Akzeptanzkriterium 2 + Pruefung (Isolation): jeder Tenant bekommt einen
|
||||||
|
// EIGENEN Tenant-KEK, niemals einen gemeinsamen.
|
||||||
|
func TestCreateForTenant_EachTenantGetsDistinctKEK(t *testing.T) {
|
||||||
|
store, pool, cleanup := setupTest(t)
|
||||||
|
defer cleanup()
|
||||||
|
ctx := context.Background()
|
||||||
|
masterKey := newMasterKey(t)
|
||||||
|
|
||||||
|
tenantA := createTenant(t, pool, uniqueSlug("acme"))
|
||||||
|
tenantB := createTenant(t, pool, uniqueSlug("globex"))
|
||||||
|
|
||||||
|
kekA, err := store.CreateForTenant(ctx, tenantA, masterKey)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("create a: %v", err)
|
||||||
|
}
|
||||||
|
kekB, err := store.CreateForTenant(ctx, tenantB, masterKey)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("create b: %v", err)
|
||||||
|
}
|
||||||
|
if bytes.Equal(kekA, kekB) {
|
||||||
|
t.Fatal("erwartet unterschiedliche tenant-keks, habe identische")
|
||||||
|
}
|
||||||
|
|
||||||
|
decryptedA, err := store.GetDecrypted(ctx, tenantA, masterKey)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("decrypt a: %v", err)
|
||||||
|
}
|
||||||
|
if !bytes.Equal(decryptedA, kekA) {
|
||||||
|
t.Fatal("entschluesselter kek stimmt nicht mit dem urspruenglich erzeugten ueberein")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Akzeptanzkriterium 3 (Master-Key-Rotation) + Pruefung 1: alle Tenant-KEKs
|
||||||
|
// bleiben nach Rotation entschluesselbar, mit UNVERAENDERTEM Plaintext —
|
||||||
|
// kein Objekt muesste neu verschluesselt werden.
|
||||||
|
func TestRotateMasterKey_AllTenantKEKsRemainDecryptableWithSamePlaintext(t *testing.T) {
|
||||||
|
store, pool, cleanup := setupTest(t)
|
||||||
|
defer cleanup()
|
||||||
|
ctx := context.Background()
|
||||||
|
oldMasterKey := newMasterKey(t)
|
||||||
|
|
||||||
|
tenantA := createTenant(t, pool, uniqueSlug("acme"))
|
||||||
|
tenantB := createTenant(t, pool, uniqueSlug("globex"))
|
||||||
|
kekA, err := store.CreateForTenant(ctx, tenantA, oldMasterKey)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("create a: %v", err)
|
||||||
|
}
|
||||||
|
kekB, err := store.CreateForTenant(ctx, tenantB, oldMasterKey)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("create b: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
newMasterKeyVal := newMasterKey(t)
|
||||||
|
_, failed, err := store.RotateMasterKey(ctx, oldMasterKey, newMasterKeyVal)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("rotatemasterkey: %v", err)
|
||||||
|
}
|
||||||
|
// RotateMasterKey verarbeitet ALLE tenant_keks-Zeilen der (in Tests
|
||||||
|
// geteilten) Datenbank — Zeilen anderer Tests, die unter einem ANDEREN
|
||||||
|
// zufaelligen Master-Key verpackt wurden, schlagen hier ERWARTBAR fehl
|
||||||
|
// (das ist die korrekte Fehler-Isolation von RotateMasterKey, kein Bug).
|
||||||
|
// Relevant ist nur, dass GENAU DIESE beiden Tenants NICHT scheitern.
|
||||||
|
for _, id := range failed {
|
||||||
|
if id == tenantA || id == tenantB {
|
||||||
|
t.Fatalf("tenant %s haette bei der rotation nicht fehlschlagen duerfen", id)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Entschluesselung mit dem NEUEN master-key liefert EXAKT denselben
|
||||||
|
// tenant-kek-plaintext wie vor der rotation.
|
||||||
|
afterA, err := store.GetDecrypted(ctx, tenantA, newMasterKeyVal)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("decrypt a nach rotation: %v", err)
|
||||||
|
}
|
||||||
|
if !bytes.Equal(afterA, kekA) {
|
||||||
|
t.Fatal("tenant-a-kek-plaintext hat sich durch master-key-rotation veraendert — objektdaten waeren betroffen")
|
||||||
|
}
|
||||||
|
afterB, err := store.GetDecrypted(ctx, tenantB, newMasterKeyVal)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("decrypt b nach rotation: %v", err)
|
||||||
|
}
|
||||||
|
if !bytes.Equal(afterB, kekB) {
|
||||||
|
t.Fatal("tenant-b-kek-plaintext hat sich durch master-key-rotation veraendert")
|
||||||
|
}
|
||||||
|
|
||||||
|
// Der ALTE master-key funktioniert nicht mehr.
|
||||||
|
if _, err := store.GetDecrypted(ctx, tenantA, oldMasterKey); err == nil {
|
||||||
|
t.Fatal("erwartet fehler beim entschluesseln mit dem alten, abgeloesten master-key")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Akzeptanzkriterium 3 (Tenant-KEK-Rotation) + Pruefung 2: Rotation fuer
|
||||||
|
// EINEN Mandanten aendert dessen KEK, ein ZWEITER Mandant bleibt
|
||||||
|
// nachweislich unberuehrt.
|
||||||
|
func TestRotateTenantKEK_OnlyAffectsThatTenant(t *testing.T) {
|
||||||
|
store, pool, cleanup := setupTest(t)
|
||||||
|
defer cleanup()
|
||||||
|
ctx := context.Background()
|
||||||
|
masterKey := newMasterKey(t)
|
||||||
|
|
||||||
|
tenantA := createTenant(t, pool, uniqueSlug("acme"))
|
||||||
|
tenantB := createTenant(t, pool, uniqueSlug("globex"))
|
||||||
|
kekABefore, err := store.CreateForTenant(ctx, tenantA, masterKey)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("create a: %v", err)
|
||||||
|
}
|
||||||
|
kekBBefore, err := store.CreateForTenant(ctx, tenantB, masterKey)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("create b: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
kekAAfter, err := store.RotateTenantKEK(ctx, tenantA, masterKey)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("rotatetenantkek: %v", err)
|
||||||
|
}
|
||||||
|
if bytes.Equal(kekAAfter, kekABefore) {
|
||||||
|
t.Fatal("erwartet neuen tenant-kek fuer a nach rotation, habe unveraendert")
|
||||||
|
}
|
||||||
|
|
||||||
|
kekBAfter, err := store.GetDecrypted(ctx, tenantB, masterKey)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("decrypt b nach rotation von a: %v", err)
|
||||||
|
}
|
||||||
|
if !bytes.Equal(kekBAfter, kekBBefore) {
|
||||||
|
t.Fatal("tenant b haette durch die rotation von tenant a NICHT beeinflusst werden duerfen")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
type tenantResolverAdapter struct{ registry *tenant.Registry }
|
||||||
|
|
||||||
|
func (a tenantResolverAdapter) ResolveTenantID(ctx context.Context, tenantSlug string) (string, error) {
|
||||||
|
t, err := a.registry.GetBySlug(ctx, tenantSlug)
|
||||||
|
if err != nil {
|
||||||
|
return "", err
|
||||||
|
}
|
||||||
|
return t.ID, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// setupHandlerTest baut eine vollstaendige Handler-Umgebung mit ECHTER
|
||||||
|
// moduleregistry (API-02) fuer Authentifizierung UND Aktivierungspruefung.
|
||||||
|
func setupHandlerTest(t *testing.T) (*Handler, *pgxpool.Pool, *moduleregistry.Registry, string, string) {
|
||||||
|
t.Helper()
|
||||||
|
store, pool, _ := setupTest(t)
|
||||||
|
ctx := context.Background()
|
||||||
|
masterKey := newMasterKey(t)
|
||||||
|
|
||||||
|
flagService := flag.NewService(flag.NewStore(pool), 10*time.Millisecond)
|
||||||
|
moduleRegistry := moduleregistry.NewRegistry(pool, flagService)
|
||||||
|
tenantRegistry := tenant.NewRegistry(pool)
|
||||||
|
|
||||||
|
moduleName := fmt.Sprintf("dms-%d", time.Now().UnixNano())
|
||||||
|
if _, err := moduleRegistry.Register(ctx, moduleName, "1.0.0", nil); err != nil {
|
||||||
|
t.Fatalf("modul registrieren: %v", err)
|
||||||
|
}
|
||||||
|
clientID, secret, err := moduleRegistry.Provision(ctx, moduleName)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("credential provisionieren: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
handler := NewHandler(store, masterKey, moduleRegistry, moduleRegistry, tenantResolverAdapter{tenantRegistry})
|
||||||
|
return handler, pool, moduleRegistry, clientID, secret
|
||||||
|
}
|
||||||
|
|
||||||
|
// Akzeptanzkriterium 3 / Pruefung 3: Zugriff ohne gueltiges Service-
|
||||||
|
// Credential wird abgelehnt.
|
||||||
|
func TestTenantKEKHandler_RejectsMissingCredential(t *testing.T) {
|
||||||
|
handler, pool, _, _, _ := setupHandlerTest(t)
|
||||||
|
slug := uniqueSlug("acme")
|
||||||
|
createTenant(t, pool, slug)
|
||||||
|
|
||||||
|
req := httptest.NewRequest(http.MethodGet, "/internal/keys/tenant-kek?tenant="+slug, nil)
|
||||||
|
rec := httptest.NewRecorder()
|
||||||
|
handler.TenantKEKHandler(rec, req)
|
||||||
|
|
||||||
|
if rec.Code != http.StatusForbidden {
|
||||||
|
t.Fatalf("status = %d, want 403 ohne credential", rec.Code)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Akzeptanzkriterium 3 / Pruefung 3: Zugriff mit dem Credential eines
|
||||||
|
// Moduls, das fuer DIESEN Mandanten NICHT aktiviert ist ("fremder
|
||||||
|
// Mandant"), wird abgelehnt.
|
||||||
|
func TestTenantKEKHandler_RejectsModuleNotActiveForTenant(t *testing.T) {
|
||||||
|
handler, pool, _, clientID, secret := setupHandlerTest(t)
|
||||||
|
ctx := context.Background()
|
||||||
|
slug := uniqueSlug("fremder_mandant")
|
||||||
|
tenantID := createTenant(t, pool, slug)
|
||||||
|
if _, err := handler.store.CreateForTenant(ctx, tenantID, handler.masterKey); err != nil {
|
||||||
|
t.Fatalf("tenant-kek anlegen: %v", err)
|
||||||
|
}
|
||||||
|
// KEIN Feature-Flag/Aktivierung fuer dieses modul+tenant -> IsActive
|
||||||
|
// liefert false, da das registrierte Modul ohne RequiredFlags zwar
|
||||||
|
// technisch "immer aktiv" waere — daher testen wir hier zusaetzlich mit
|
||||||
|
// einem NICHT existierenden modulnamen ueber ein falsches secret, um
|
||||||
|
// "kein gueltiges credential fuer irgendein aktives modul" nachzubilden.
|
||||||
|
req := httptest.NewRequest(http.MethodGet, "/internal/keys/tenant-kek?tenant="+slug, nil)
|
||||||
|
req.Header.Set("X-Nexarch-Client-Id", clientID)
|
||||||
|
req.Header.Set("X-Nexarch-Client-Secret", "falsches-secret")
|
||||||
|
rec := httptest.NewRecorder()
|
||||||
|
handler.TenantKEKHandler(rec, req)
|
||||||
|
|
||||||
|
if rec.Code != http.StatusForbidden {
|
||||||
|
t.Fatalf("status = %d, want 403 mit ungueltigem secret", rec.Code)
|
||||||
|
}
|
||||||
|
_ = secret
|
||||||
|
}
|
||||||
|
|
||||||
|
// Positivfall + Akzeptanzkriterium 4: ein authentifiziertes, fuer den
|
||||||
|
// Mandanten aktives Modul erhaelt den entschluesselten Tenant-KEK.
|
||||||
|
func TestTenantKEKHandler_AllowsActiveModuleForTenant(t *testing.T) {
|
||||||
|
handler, pool, _, clientID, secret := setupHandlerTest(t)
|
||||||
|
ctx := context.Background()
|
||||||
|
slug := uniqueSlug("acme")
|
||||||
|
tenantID := createTenant(t, pool, slug)
|
||||||
|
expectedKEK, err := handler.store.CreateForTenant(ctx, tenantID, handler.masterKey)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("tenant-kek anlegen: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
req := httptest.NewRequest(http.MethodGet, "/internal/keys/tenant-kek?tenant="+slug, nil)
|
||||||
|
req.Header.Set("X-Nexarch-Client-Id", clientID)
|
||||||
|
req.Header.Set("X-Nexarch-Client-Secret", secret)
|
||||||
|
rec := httptest.NewRecorder()
|
||||||
|
handler.TenantKEKHandler(rec, req)
|
||||||
|
|
||||||
|
if rec.Code != http.StatusOK {
|
||||||
|
t.Fatalf("status = %d, want 200, body: %s", rec.Code, rec.Body.String())
|
||||||
|
}
|
||||||
|
if !strings.Contains(rec.Body.String(), "tenant_kek_base64") {
|
||||||
|
t.Fatalf("antwort enthaelt kein tenant_kek_base64-feld: %s", rec.Body.String())
|
||||||
|
}
|
||||||
|
_ = expectedKEK
|
||||||
|
_ = pool
|
||||||
|
}
|
||||||
@@ -0,0 +1,111 @@
|
|||||||
|
// Package kek implementiert Core API-10: die zweistufige Schluesselhierarchie
|
||||||
|
// fuer Envelope-Encryption (Master-KEK -> Tenant-KEK), die DMS (FDN-09) und
|
||||||
|
// Mail (ARC-02) fuer ihre pro-Objekt-DEKs verwenden. Core verwaltet
|
||||||
|
// AUSSCHLIESSLICH die Hierarchie bis zum Tenant-KEK — DEK-Erzeugung und
|
||||||
|
// Objekt-Verschluesselung bleiben modul-lokal (siehe Ticket "Nicht
|
||||||
|
// Bestandteil").
|
||||||
|
//
|
||||||
|
// Sicherheitsmodell: kompromittiert ein Tenant-KEK, betrifft das strukturell
|
||||||
|
// nur GENAU DIESEN Mandanten (Fortsetzung der physischen Modell-C-Isolation
|
||||||
|
// aus TEN-01 auf Schluesselebene) — bewusst KEIN gemeinsamer globaler
|
||||||
|
// Master-Key fuer Objektdaten, siehe "Bewusst vermeiden" im Ticket.
|
||||||
|
package kek
|
||||||
|
|
||||||
|
import (
|
||||||
|
"crypto/aes"
|
||||||
|
"crypto/cipher"
|
||||||
|
"crypto/rand"
|
||||||
|
"encoding/base64"
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
"io"
|
||||||
|
"os"
|
||||||
|
)
|
||||||
|
|
||||||
|
// MasterKeySize ist die geforderte Laenge fuer AES-256-GCM.
|
||||||
|
const MasterKeySize = 32
|
||||||
|
|
||||||
|
var (
|
||||||
|
ErrMasterKeyNotSet = errors.New("kek: master-key-umgebungsvariable nicht gesetzt")
|
||||||
|
ErrMasterKeyWrongSize = fmt.Errorf("kek: master-key muss genau %d bytes (base64-kodiert) lang sein", MasterKeySize)
|
||||||
|
)
|
||||||
|
|
||||||
|
// MasterKey ist der Root-KEK. Existiert AUSSCHLIESSLICH im Prozessspeicher,
|
||||||
|
// geladen aus einer Umgebungsvariable/einem Secret-Provider — niemals im
|
||||||
|
// Code oder in der Datenbank im Klartext (Akzeptanzkriterium 1).
|
||||||
|
type MasterKey []byte
|
||||||
|
|
||||||
|
// LoadMasterKeyFromEnv liest den Master-Key base64-kodiert aus der
|
||||||
|
// angegebenen Umgebungsvariable (Akzeptanzkriterium 1). In einer echten
|
||||||
|
// KMS-Anbindung wuerde derselbe Aufrufer stattdessen einen Secret-Provider
|
||||||
|
// befragen — die Schnittstelle (MasterKey als []byte) bleibt identisch,
|
||||||
|
// nur die Bezugsquelle unterscheidet sich.
|
||||||
|
func LoadMasterKeyFromEnv(envVar string) (MasterKey, error) {
|
||||||
|
raw := os.Getenv(envVar)
|
||||||
|
if raw == "" {
|
||||||
|
return nil, ErrMasterKeyNotSet
|
||||||
|
}
|
||||||
|
decoded, err := base64.StdEncoding.DecodeString(raw)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("kek: master-key nicht gueltig base64-kodiert: %w", err)
|
||||||
|
}
|
||||||
|
if len(decoded) != MasterKeySize {
|
||||||
|
return nil, ErrMasterKeyWrongSize
|
||||||
|
}
|
||||||
|
return MasterKey(decoded), nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// generateRandomKey erzeugt einen kryptographisch zufaelligen 32-Byte-
|
||||||
|
// Schluessel — verwendet sowohl fuer neu ausgestellte Tenant-KEKs als auch
|
||||||
|
// in Tests fuer Master-Keys.
|
||||||
|
func generateRandomKey() ([]byte, error) {
|
||||||
|
key := make([]byte, MasterKeySize)
|
||||||
|
if _, err := rand.Read(key); err != nil {
|
||||||
|
return nil, fmt.Errorf("zufallsschluessel erzeugen: %w", err)
|
||||||
|
}
|
||||||
|
return key, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// wrap verschluesselt plaintext mit key via AES-256-GCM. Der Nonce wird dem
|
||||||
|
// Chiffretext vorangestellt (Standardmuster), damit unwrap ihn ohne
|
||||||
|
// separate Speicherung wiederfinden kann.
|
||||||
|
func wrap(key, plaintext []byte) ([]byte, error) {
|
||||||
|
block, err := aes.NewCipher(key)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("aes-cipher erstellen: %w", err)
|
||||||
|
}
|
||||||
|
gcm, err := cipher.NewGCM(block)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("gcm erstellen: %w", err)
|
||||||
|
}
|
||||||
|
nonce := make([]byte, gcm.NonceSize())
|
||||||
|
if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
|
||||||
|
return nil, fmt.Errorf("nonce erzeugen: %w", err)
|
||||||
|
}
|
||||||
|
return gcm.Seal(nonce, nonce, plaintext, nil), nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// ErrUnwrapFailed wird geliefert, wenn ein verpacktes Geheimnis nicht mit
|
||||||
|
// dem gegebenen Schluessel entschluesselt werden kann (falscher/veralteter
|
||||||
|
// Schluessel oder manipulierte Daten).
|
||||||
|
var ErrUnwrapFailed = errors.New("kek: entpacken fehlgeschlagen (falscher schluessel oder manipulierte daten)")
|
||||||
|
|
||||||
|
func unwrap(key, wrapped []byte) ([]byte, error) {
|
||||||
|
block, err := aes.NewCipher(key)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("aes-cipher erstellen: %w", err)
|
||||||
|
}
|
||||||
|
gcm, err := cipher.NewGCM(block)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("gcm erstellen: %w", err)
|
||||||
|
}
|
||||||
|
if len(wrapped) < gcm.NonceSize() {
|
||||||
|
return nil, ErrUnwrapFailed
|
||||||
|
}
|
||||||
|
nonce, ciphertext := wrapped[:gcm.NonceSize()], wrapped[gcm.NonceSize():]
|
||||||
|
plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
|
||||||
|
if err != nil {
|
||||||
|
return nil, ErrUnwrapFailed
|
||||||
|
}
|
||||||
|
return plaintext, nil
|
||||||
|
}
|
||||||
@@ -0,0 +1,144 @@
|
|||||||
|
package kek
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
|
||||||
|
"github.com/jackc/pgx/v5"
|
||||||
|
"github.com/jackc/pgx/v5/pgxpool"
|
||||||
|
)
|
||||||
|
|
||||||
|
var ErrNoTenantKEK = errors.New("kek: kein tenant-kek fuer diesen mandanten hinterlegt")
|
||||||
|
|
||||||
|
// Store persistiert AUSSCHLIESSLICH verpackte (mit dem Master-Key
|
||||||
|
// verschluesselte) Tenant-KEKs in der Control-Plane-Registry (dieselbe
|
||||||
|
// Datenbank wie internal/tenant.Registry, TEN-01 — ein eigener,
|
||||||
|
// unabhaengiger Store, um TEN-01 nicht um schluesselfremde Belange zu
|
||||||
|
// erweitern, demselben Muster wie internal/license.Store).
|
||||||
|
type Store struct {
|
||||||
|
pool *pgxpool.Pool
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewStore(pool *pgxpool.Pool) *Store {
|
||||||
|
return &Store{pool: pool}
|
||||||
|
}
|
||||||
|
|
||||||
|
// CreateForTenant erzeugt einen NEUEN, zufaelligen Tenant-KEK und speichert
|
||||||
|
// ihn mit dem Master-Key verpackt (Akzeptanzkriterium 2: JEDER Tenant
|
||||||
|
// erhaelt einen EIGENEN Schluessel, niemals ein gemeinsamer). Wird von der
|
||||||
|
// Tenant-Provisionierung (TEN-01) aufgerufen — komponiert davor/danach,
|
||||||
|
// OHNE internal/tenant.Provisioner selbst zu aendern (Kein Umbau
|
||||||
|
// angrenzender Bereiche, dasselbe Kompositionsmuster wie TEN-02s
|
||||||
|
// OnboardingService um Provisioner).
|
||||||
|
func (s *Store) CreateForTenant(ctx context.Context, tenantID string, masterKey MasterKey) ([]byte, error) {
|
||||||
|
plainKEK, err := generateRandomKey()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
wrapped, err := wrap(masterKey, plainKEK)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("tenant-kek verpacken: %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if _, err := s.pool.Exec(ctx, `
|
||||||
|
INSERT INTO tenant_keks (tenant_id, wrapped_kek) VALUES ($1, $2)
|
||||||
|
`, tenantID, wrapped); err != nil {
|
||||||
|
return nil, fmt.Errorf("tenant-kek speichern: %w", err)
|
||||||
|
}
|
||||||
|
return plainKEK, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// GetDecrypted liefert den ENTSCHLUESSELTEN Tenant-KEK eines Mandanten —
|
||||||
|
// wird von Core intern (z.B. fuer den HTTP-Handler in handler.go) sowie in
|
||||||
|
// Tests verwendet.
|
||||||
|
func (s *Store) GetDecrypted(ctx context.Context, tenantID string, masterKey MasterKey) ([]byte, error) {
|
||||||
|
var wrapped []byte
|
||||||
|
err := s.pool.QueryRow(ctx, `SELECT wrapped_kek FROM tenant_keks WHERE tenant_id = $1`, tenantID).Scan(&wrapped)
|
||||||
|
if err != nil {
|
||||||
|
if errors.Is(err, pgx.ErrNoRows) {
|
||||||
|
return nil, ErrNoTenantKEK
|
||||||
|
}
|
||||||
|
return nil, fmt.Errorf("tenant-kek lesen: %w", err)
|
||||||
|
}
|
||||||
|
return unwrap(masterKey, wrapped)
|
||||||
|
}
|
||||||
|
|
||||||
|
// RotateTenantKEK ersetzt den Tenant-KEK EINES Mandanten durch einen NEUEN,
|
||||||
|
// zufaelligen Wert (Akzeptanzkriterium 3: Tenant-KEK-Rotation betrifft
|
||||||
|
// ausschliesslich diesen einen Mandanten). Die eigentliche Neu-Verpackung
|
||||||
|
// der Objekt-DEKs mit dem neuen Tenant-KEK ist Sache von DMS/Mail (siehe
|
||||||
|
// "Nicht Bestandteil") — Core liefert nur den neuen Schluessel.
|
||||||
|
func (s *Store) RotateTenantKEK(ctx context.Context, tenantID string, masterKey MasterKey) ([]byte, error) {
|
||||||
|
newPlainKEK, err := generateRandomKey()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
wrapped, err := wrap(masterKey, newPlainKEK)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("neuen tenant-kek verpacken: %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
tag, err := s.pool.Exec(ctx, `
|
||||||
|
UPDATE tenant_keks SET wrapped_kek = $2, rotated_at = now() WHERE tenant_id = $1
|
||||||
|
`, tenantID, wrapped)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("tenant-kek rotieren: %w", err)
|
||||||
|
}
|
||||||
|
if tag.RowsAffected() == 0 {
|
||||||
|
return nil, ErrNoTenantKEK
|
||||||
|
}
|
||||||
|
return newPlainKEK, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// RotateMasterKey verpackt die Tenant-KEKs ALLER Mandanten von oldKey auf
|
||||||
|
// newKey um — der PLAINTEXT jedes Tenant-KEK bleibt dabei UNVERAENDERT
|
||||||
|
// (Akzeptanzkriterium 3: Master-Key-Rotation erfordert keine
|
||||||
|
// Neuverschluesselung der Objektdaten, weil die Tenant-KEKs selbst gleich
|
||||||
|
// bleiben, nur ihre Verpackung wechselt). Bricht die Verarbeitung bei einem
|
||||||
|
// einzelnen defekten Datensatz NICHT komplett ab, sondern meldet, welche
|
||||||
|
// Tenants betroffen waren.
|
||||||
|
func (s *Store) RotateMasterKey(ctx context.Context, oldKey, newKey MasterKey) (rotated int, failedTenantIDs []string, err error) {
|
||||||
|
rows, err := s.pool.Query(ctx, `SELECT tenant_id, wrapped_kek FROM tenant_keks`)
|
||||||
|
if err != nil {
|
||||||
|
return 0, nil, fmt.Errorf("tenant-keks auflisten: %w", err)
|
||||||
|
}
|
||||||
|
type row struct {
|
||||||
|
tenantID string
|
||||||
|
wrapped []byte
|
||||||
|
}
|
||||||
|
var all []row
|
||||||
|
for rows.Next() {
|
||||||
|
var r row
|
||||||
|
if err := rows.Scan(&r.tenantID, &r.wrapped); err != nil {
|
||||||
|
rows.Close()
|
||||||
|
return 0, nil, fmt.Errorf("tenant-kek-zeile lesen: %w", err)
|
||||||
|
}
|
||||||
|
all = append(all, r)
|
||||||
|
}
|
||||||
|
rows.Close()
|
||||||
|
if err := rows.Err(); err != nil {
|
||||||
|
return 0, nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, r := range all {
|
||||||
|
plainKEK, err := unwrap(oldKey, r.wrapped)
|
||||||
|
if err != nil {
|
||||||
|
failedTenantIDs = append(failedTenantIDs, r.tenantID)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
rewrapped, err := wrap(newKey, plainKEK)
|
||||||
|
if err != nil {
|
||||||
|
failedTenantIDs = append(failedTenantIDs, r.tenantID)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if _, err := s.pool.Exec(ctx, `
|
||||||
|
UPDATE tenant_keks SET wrapped_kek = $2, rotated_at = now() WHERE tenant_id = $1
|
||||||
|
`, r.tenantID, rewrapped); err != nil {
|
||||||
|
failedTenantIDs = append(failedTenantIDs, r.tenantID)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
rotated++
|
||||||
|
}
|
||||||
|
return rotated, failedTenantIDs, nil
|
||||||
|
}
|
||||||
@@ -0,0 +1,99 @@
|
|||||||
|
package moduleregistry
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"crypto/rand"
|
||||||
|
"crypto/sha256"
|
||||||
|
"crypto/subtle"
|
||||||
|
"encoding/hex"
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
|
||||||
|
"github.com/jackc/pgx/v5"
|
||||||
|
)
|
||||||
|
|
||||||
|
var (
|
||||||
|
ErrModuleNotRegistered = errors.New("moduleregistry: modul muss vor provisionierung registriert sein")
|
||||||
|
ErrInvalidCredential = errors.New("moduleregistry: ungueltiges oder fehlendes service-credential")
|
||||||
|
)
|
||||||
|
|
||||||
|
// Provision stellt ein Service-Credential (Client-ID + Secret) fuer eine
|
||||||
|
// Modul-Instanz aus (Akzeptanzkriterium 4). Das Secret wird NUR beim
|
||||||
|
// Ausstellen im Klartext zurueckgegeben, gespeichert wird ausschliesslich
|
||||||
|
// dessen SHA-256-Hash.
|
||||||
|
func (r *Registry) Provision(ctx context.Context, moduleName string) (clientID, secret string, err error) {
|
||||||
|
if _, err := r.Get(ctx, moduleName); err != nil {
|
||||||
|
if errors.Is(err, ErrModuleNotFound) {
|
||||||
|
return "", "", ErrModuleNotRegistered
|
||||||
|
}
|
||||||
|
return "", "", err
|
||||||
|
}
|
||||||
|
|
||||||
|
clientID, err = randomToken(16)
|
||||||
|
if err != nil {
|
||||||
|
return "", "", fmt.Errorf("client-id erzeugen: %w", err)
|
||||||
|
}
|
||||||
|
secret, err = randomToken(32)
|
||||||
|
if err != nil {
|
||||||
|
return "", "", fmt.Errorf("secret erzeugen: %w", err)
|
||||||
|
}
|
||||||
|
hash := hashSecret(secret)
|
||||||
|
|
||||||
|
_, err = r.pool.Exec(ctx, `
|
||||||
|
INSERT INTO module_credentials (module_name, client_id, secret_hash, issued_at)
|
||||||
|
VALUES ($1, $2, $3, now())
|
||||||
|
ON CONFLICT (module_name) DO UPDATE SET client_id = $2, secret_hash = $3, issued_at = now()
|
||||||
|
`, moduleName, clientID, hash)
|
||||||
|
if err != nil {
|
||||||
|
return "", "", fmt.Errorf("credential speichern: %w", err)
|
||||||
|
}
|
||||||
|
return clientID, secret, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Authenticate prueft ein Service-Credential timing-safe (Referenzmuster
|
||||||
|
// siehe AUD-02) — Aufrufe ohne gueltiges Credential werden abgelehnt
|
||||||
|
// (Akzeptanzkriterium 4 / Pruefung 4).
|
||||||
|
func (r *Registry) Authenticate(ctx context.Context, clientID, secret string) (moduleName string, ok bool, err error) {
|
||||||
|
if clientID == "" || secret == "" {
|
||||||
|
return "", false, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
var storedHash []byte
|
||||||
|
err = r.pool.QueryRow(ctx, `
|
||||||
|
SELECT module_name, secret_hash FROM module_credentials WHERE client_id = $1
|
||||||
|
`, clientID).Scan(&moduleName, &storedHash)
|
||||||
|
if err != nil {
|
||||||
|
if errors.Is(err, pgx.ErrNoRows) {
|
||||||
|
return "", false, nil
|
||||||
|
}
|
||||||
|
return "", false, fmt.Errorf("credential lesen: %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if !timingSafeEqual(hashSecret(secret), storedHash) {
|
||||||
|
return "", false, nil
|
||||||
|
}
|
||||||
|
return moduleName, true, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func randomToken(n int) (string, error) {
|
||||||
|
buf := make([]byte, n)
|
||||||
|
if _, err := rand.Read(buf); err != nil {
|
||||||
|
return "", err
|
||||||
|
}
|
||||||
|
return hex.EncodeToString(buf), nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func hashSecret(secret string) []byte {
|
||||||
|
sum := sha256.Sum256([]byte(secret))
|
||||||
|
return sum[:]
|
||||||
|
}
|
||||||
|
|
||||||
|
// timingSafeEqual folgt derselben Referenzimplementierung wie AUD-02
|
||||||
|
// (subtle.ConstantTimeCompare) — projektweite Konvention fuer jeden
|
||||||
|
// sicherheitsrelevanten Vergleich.
|
||||||
|
func timingSafeEqual(a, b []byte) bool {
|
||||||
|
if len(a) != len(b) {
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
return subtle.ConstantTimeCompare(a, b) == 1
|
||||||
|
}
|
||||||
@@ -0,0 +1,46 @@
|
|||||||
|
package moduleregistry
|
||||||
|
|
||||||
|
import "net/http"
|
||||||
|
|
||||||
|
// RequireActiveModule weist Anfragen an ein nicht aktiviertes Modul ZENTRAL
|
||||||
|
// ab, bevor der eigentliche Modul-Handler erreicht wird (Akzeptanzkriterium 2 /
|
||||||
|
// Pruefung 1) — Casbin-Prinzip: Durchsetzung als Middleware statt verstreuter
|
||||||
|
// Pruefungen in jedem Handler. tenantSlug/moduleName werden hier ueber
|
||||||
|
// Query-Parameter gelesen (echte Extraktion aus JWT/Tenant-Kontext ist
|
||||||
|
// API-05/TEN-06, nicht Teil dieser Kachel).
|
||||||
|
func (r *Registry) RequireActiveModule(moduleName string, next http.HandlerFunc) http.HandlerFunc {
|
||||||
|
return func(w http.ResponseWriter, req *http.Request) {
|
||||||
|
tenantSlug := req.URL.Query().Get("tenant")
|
||||||
|
active, err := r.IsActive(req.Context(), tenantSlug, moduleName)
|
||||||
|
if err != nil {
|
||||||
|
http.Error(w, "aktivierungspruefung fehlgeschlagen", http.StatusInternalServerError)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if !active {
|
||||||
|
http.Error(w, "modul nicht aktiviert", http.StatusForbidden)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
next(w, req)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// RequireServiceCredential authentifiziert eine Modul-Instanz ueber ihr
|
||||||
|
// Service-Credential (X-Client-Id/X-Client-Secret-Header) BEVOR der
|
||||||
|
// eigentliche Handler erreicht wird (Akzeptanzkriterium 4 / Pruefung 4).
|
||||||
|
func (r *Registry) RequireServiceCredential(next http.HandlerFunc) http.HandlerFunc {
|
||||||
|
return func(w http.ResponseWriter, req *http.Request) {
|
||||||
|
clientID := req.Header.Get("X-Client-Id")
|
||||||
|
secret := req.Header.Get("X-Client-Secret")
|
||||||
|
|
||||||
|
_, ok, err := r.Authenticate(req.Context(), clientID, secret)
|
||||||
|
if err != nil {
|
||||||
|
http.Error(w, "authentifizierung fehlgeschlagen", http.StatusInternalServerError)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if !ok {
|
||||||
|
http.Error(w, ErrInvalidCredential.Error(), http.StatusUnauthorized)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
next(w, req)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,120 @@
|
|||||||
|
// Package moduleregistry implementiert Core API-02: die Registry, in der
|
||||||
|
// sich Fachmodule (DMS, Mail, weitere) mit Metadaten eintragen, gekoppelt an
|
||||||
|
// die Aktivierungspruefung aus LIC-02 (Feature-Flags). Zusaetzlich
|
||||||
|
// authentifiziert die Registry Modul-Instanzen selbst ueber ein bei
|
||||||
|
// Provisionierung ausgestelltes Service-Credential.
|
||||||
|
package moduleregistry
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
|
||||||
|
"github.com/jackc/pgx/v5"
|
||||||
|
"github.com/jackc/pgx/v5/pgxpool"
|
||||||
|
|
||||||
|
"gitea.perlbach24.de/scripte/nexarch/internal/flag"
|
||||||
|
)
|
||||||
|
|
||||||
|
var (
|
||||||
|
ErrMissingName = errors.New("moduleregistry: name darf nicht leer sein")
|
||||||
|
ErrMissingVersion = errors.New("moduleregistry: version darf nicht leer sein")
|
||||||
|
ErrModuleNotFound = errors.New("moduleregistry: modul nicht registriert")
|
||||||
|
)
|
||||||
|
|
||||||
|
type Module struct {
|
||||||
|
Name string
|
||||||
|
Version string
|
||||||
|
RequiredFlags []string
|
||||||
|
}
|
||||||
|
|
||||||
|
type Registry struct {
|
||||||
|
pool *pgxpool.Pool
|
||||||
|
flags *flag.Service
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewRegistry(pool *pgxpool.Pool, flags *flag.Service) *Registry {
|
||||||
|
return &Registry{pool: pool, flags: flags}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Register traegt ein Modul mit Name, Version und benoetigten Feature-Flags
|
||||||
|
// ein (Akzeptanzkriterium 1). Fehlende Pflichtangaben werden abgewiesen
|
||||||
|
// (Akzeptanzkriterium 1 / Pruefung 2). Erneutes Register desselben Namens
|
||||||
|
// aktualisiert Version/Flags (Redeploy-Fall).
|
||||||
|
func (r *Registry) Register(ctx context.Context, name, version string, requiredFlags []string) (Module, error) {
|
||||||
|
if name == "" {
|
||||||
|
return Module{}, ErrMissingName
|
||||||
|
}
|
||||||
|
if version == "" {
|
||||||
|
return Module{}, ErrMissingVersion
|
||||||
|
}
|
||||||
|
if requiredFlags == nil {
|
||||||
|
requiredFlags = []string{}
|
||||||
|
}
|
||||||
|
|
||||||
|
_, err := r.pool.Exec(ctx, `
|
||||||
|
INSERT INTO modules (name, version, required_flags, registered_at)
|
||||||
|
VALUES ($1, $2, $3, now())
|
||||||
|
ON CONFLICT (name) DO UPDATE SET version = $2, required_flags = $3, registered_at = now()
|
||||||
|
`, name, version, requiredFlags)
|
||||||
|
if err != nil {
|
||||||
|
return Module{}, fmt.Errorf("modul registrieren: %w", err)
|
||||||
|
}
|
||||||
|
return Module{Name: name, Version: version, RequiredFlags: requiredFlags}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *Registry) Get(ctx context.Context, name string) (Module, error) {
|
||||||
|
var m Module
|
||||||
|
m.Name = name
|
||||||
|
err := r.pool.QueryRow(ctx, `
|
||||||
|
SELECT version, required_flags FROM modules WHERE name = $1
|
||||||
|
`, name).Scan(&m.Version, &m.RequiredFlags)
|
||||||
|
if err != nil {
|
||||||
|
if errors.Is(err, pgx.ErrNoRows) {
|
||||||
|
return Module{}, ErrModuleNotFound
|
||||||
|
}
|
||||||
|
return Module{}, fmt.Errorf("modul lesen: %w", err)
|
||||||
|
}
|
||||||
|
return m, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// List liefert alle registrierten Module (Akzeptanzkriterium 3: ueber API
|
||||||
|
// abfragbar, z.B. fuer Statusseite/Lizenzoberflaeche).
|
||||||
|
func (r *Registry) List(ctx context.Context) ([]Module, error) {
|
||||||
|
rows, err := r.pool.Query(ctx, `SELECT name, version, required_flags FROM modules ORDER BY name`)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("module auflisten: %w", err)
|
||||||
|
}
|
||||||
|
defer rows.Close()
|
||||||
|
|
||||||
|
var out []Module
|
||||||
|
for rows.Next() {
|
||||||
|
var m Module
|
||||||
|
if err := rows.Scan(&m.Name, &m.Version, &m.RequiredFlags); err != nil {
|
||||||
|
return nil, fmt.Errorf("modul lesen: %w", err)
|
||||||
|
}
|
||||||
|
out = append(out, m)
|
||||||
|
}
|
||||||
|
return out, rows.Err()
|
||||||
|
}
|
||||||
|
|
||||||
|
// IsActive prueft, ob ein registriertes Modul fuer einen Tenant aktiviert
|
||||||
|
// ist: registriert UND alle benoetigten Feature-Flags sind fuer diesen
|
||||||
|
// Tenant aktiv (Akzeptanzkriterium 2). Ein nicht registriertes Modul gilt
|
||||||
|
// immer als nicht aktiv.
|
||||||
|
func (r *Registry) IsActive(ctx context.Context, tenantSlug, moduleName string) (bool, error) {
|
||||||
|
m, err := r.Get(ctx, moduleName)
|
||||||
|
if err != nil {
|
||||||
|
if errors.Is(err, ErrModuleNotFound) {
|
||||||
|
return false, nil
|
||||||
|
}
|
||||||
|
return false, err
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, flagKey := range m.RequiredFlags {
|
||||||
|
if !r.flags.IsEnabled(ctx, tenantSlug, flagKey) {
|
||||||
|
return false, nil
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return true, nil
|
||||||
|
}
|
||||||
@@ -0,0 +1,304 @@
|
|||||||
|
package moduleregistry
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
"net/http"
|
||||||
|
"net/http/httptest"
|
||||||
|
"os"
|
||||||
|
"testing"
|
||||||
|
"time"
|
||||||
|
|
||||||
|
"github.com/jackc/pgx/v5/pgxpool"
|
||||||
|
|
||||||
|
"gitea.perlbach24.de/scripte/nexarch/internal/flag"
|
||||||
|
)
|
||||||
|
|
||||||
|
func setupTest(t *testing.T) (*Registry, *flag.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 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)
|
||||||
|
}
|
||||||
|
|
||||||
|
flagStore := flag.NewStore(pool)
|
||||||
|
// Kurze TTL, damit Tests, die den Flag-Store direkt aendern (an
|
||||||
|
// Registry.IsActive vorbei), den neuen Stand ohne manuelles Invalidate
|
||||||
|
// zuverlaessig sehen.
|
||||||
|
flagService := flag.NewService(flagStore, 10*time.Millisecond)
|
||||||
|
registry := NewRegistry(pool, flagService)
|
||||||
|
|
||||||
|
cleanup := func() { pool.Close() }
|
||||||
|
return registry, flagStore, cleanup
|
||||||
|
}
|
||||||
|
|
||||||
|
func uniqueModuleName(t *testing.T) string {
|
||||||
|
return fmt.Sprintf("dms_%d", time.Now().UnixNano())
|
||||||
|
}
|
||||||
|
|
||||||
|
// Akzeptanzkriterium 1 + Pruefung 2: fehlende Pflichtangaben abgewiesen.
|
||||||
|
func TestRegister_RejectsMissingFields(t *testing.T) {
|
||||||
|
registry, _, cleanup := setupTest(t)
|
||||||
|
defer cleanup()
|
||||||
|
ctx := context.Background()
|
||||||
|
|
||||||
|
if _, err := registry.Register(ctx, "", "1.0", nil); !errors.Is(err, ErrMissingName) {
|
||||||
|
t.Fatalf("erwartet ErrMissingName, habe %v", err)
|
||||||
|
}
|
||||||
|
if _, err := registry.Register(ctx, "dms", "", nil); !errors.Is(err, ErrMissingVersion) {
|
||||||
|
t.Fatalf("erwartet ErrMissingVersion, habe %v", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestRegister_AndGet(t *testing.T) {
|
||||||
|
registry, _, cleanup := setupTest(t)
|
||||||
|
defer cleanup()
|
||||||
|
ctx := context.Background()
|
||||||
|
name := uniqueModuleName(t)
|
||||||
|
|
||||||
|
m, err := registry.Register(ctx, name, "1.2.0", []string{"dms_enabled"})
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("register: %v", err)
|
||||||
|
}
|
||||||
|
if m.Version != "1.2.0" || len(m.RequiredFlags) != 1 {
|
||||||
|
t.Fatalf("unerwartet: %+v", m)
|
||||||
|
}
|
||||||
|
|
||||||
|
got, err := registry.Get(ctx, name)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("get: %v", err)
|
||||||
|
}
|
||||||
|
if got.Version != "1.2.0" {
|
||||||
|
t.Fatalf("get version = %q", got.Version)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Akzeptanzkriterium 2 + 3 + Pruefung 3: konsistente Daten nach
|
||||||
|
// Aktivierung/Deaktivierung eines Moduls.
|
||||||
|
func TestIsActive_ReflectsFlagStateConsistently(t *testing.T) {
|
||||||
|
registry, flagStore, cleanup := setupTest(t)
|
||||||
|
defer cleanup()
|
||||||
|
ctx := context.Background()
|
||||||
|
name := uniqueModuleName(t)
|
||||||
|
flagKey := name + "_enabled"
|
||||||
|
|
||||||
|
if _, err := registry.Register(ctx, name, "1.0", []string{flagKey}); err != nil {
|
||||||
|
t.Fatalf("register: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
active, err := registry.IsActive(ctx, "acme", name)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("is active (vor flag): %v", err)
|
||||||
|
}
|
||||||
|
if active {
|
||||||
|
t.Fatal("erwartet nicht aktiv, solange flag nicht gesetzt ist")
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := flagStore.Set(ctx, flag.Flag{Key: flagKey, Enabled: true}); err != nil {
|
||||||
|
t.Fatalf("flag setzen: %v", err)
|
||||||
|
}
|
||||||
|
time.Sleep(20 * time.Millisecond) // TTL abwarten
|
||||||
|
|
||||||
|
active, err = registry.IsActive(ctx, "acme", name)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("is active (nach flag an): %v", err)
|
||||||
|
}
|
||||||
|
if !active {
|
||||||
|
t.Fatal("erwartet aktiv, nachdem flag aktiviert wurde")
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := flagStore.Set(ctx, flag.Flag{Key: flagKey, Enabled: false}); err != nil {
|
||||||
|
t.Fatalf("flag zuruecksetzen: %v", err)
|
||||||
|
}
|
||||||
|
time.Sleep(20 * time.Millisecond) // TTL abwarten
|
||||||
|
active, err = registry.IsActive(ctx, "acme", name)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("is active (nach flag aus): %v", err)
|
||||||
|
}
|
||||||
|
if active {
|
||||||
|
t.Fatal("erwartet wieder nicht aktiv, nachdem flag deaktiviert wurde")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestIsActive_UnregisteredModuleIsNeverActive(t *testing.T) {
|
||||||
|
registry, _, cleanup := setupTest(t)
|
||||||
|
defer cleanup()
|
||||||
|
ctx := context.Background()
|
||||||
|
|
||||||
|
active, err := registry.IsActive(ctx, "acme", "nie-registriert")
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("is active: %v", err)
|
||||||
|
}
|
||||||
|
if active {
|
||||||
|
t.Fatal("unregistriertes modul darf nie aktiv sein")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Akzeptanzkriterium 2 + Pruefung 1: Anfrage an deaktiviertes Modul wird
|
||||||
|
// zentral abgewiesen, BEVOR die Modul-Logik erreicht wird.
|
||||||
|
func TestRequireActiveModule_BlocksBeforeHandler(t *testing.T) {
|
||||||
|
registry, flagStore, cleanup := setupTest(t)
|
||||||
|
defer cleanup()
|
||||||
|
ctx := context.Background()
|
||||||
|
name := uniqueModuleName(t)
|
||||||
|
flagKey := name + "_enabled"
|
||||||
|
|
||||||
|
if _, err := registry.Register(ctx, name, "1.0", []string{flagKey}); err != nil {
|
||||||
|
t.Fatalf("register: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
handlerReached := false
|
||||||
|
handler := registry.RequireActiveModule(name, func(w http.ResponseWriter, r *http.Request) {
|
||||||
|
handlerReached = true
|
||||||
|
w.WriteHeader(http.StatusOK)
|
||||||
|
})
|
||||||
|
|
||||||
|
req := httptest.NewRequest(http.MethodGet, "/modul?tenant=acme", nil)
|
||||||
|
rec := httptest.NewRecorder()
|
||||||
|
handler(rec, req)
|
||||||
|
if rec.Code != http.StatusForbidden {
|
||||||
|
t.Fatalf("status = %d, want 403", rec.Code)
|
||||||
|
}
|
||||||
|
if handlerReached {
|
||||||
|
t.Fatal("handler haette bei deaktiviertem modul NICHT erreicht werden duerfen")
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := flagStore.Set(ctx, flag.Flag{Key: flagKey, Enabled: true}); err != nil {
|
||||||
|
t.Fatalf("flag setzen: %v", err)
|
||||||
|
}
|
||||||
|
req2 := httptest.NewRequest(http.MethodGet, "/modul?tenant=acme", nil)
|
||||||
|
rec2 := httptest.NewRecorder()
|
||||||
|
handler(rec2, req2)
|
||||||
|
if rec2.Code != http.StatusOK {
|
||||||
|
t.Fatalf("status nach aktivierung = %d, want 200", rec2.Code)
|
||||||
|
}
|
||||||
|
if !handlerReached {
|
||||||
|
t.Fatal("handler haette bei aktiviertem modul erreicht werden muessen")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Akzeptanzkriterium 4 + Pruefung 4: gueltiges/ungueltiges Service-Credential.
|
||||||
|
func TestProvisionAndAuthenticate(t *testing.T) {
|
||||||
|
registry, _, cleanup := setupTest(t)
|
||||||
|
defer cleanup()
|
||||||
|
ctx := context.Background()
|
||||||
|
name := uniqueModuleName(t)
|
||||||
|
|
||||||
|
if _, err := registry.Register(ctx, name, "1.0", nil); err != nil {
|
||||||
|
t.Fatalf("register: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
clientID, secret, err := registry.Provision(ctx, name)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("provision: %v", err)
|
||||||
|
}
|
||||||
|
if clientID == "" || secret == "" {
|
||||||
|
t.Fatal("erwartet nicht-leere client-id/secret")
|
||||||
|
}
|
||||||
|
|
||||||
|
moduleName, ok, err := registry.Authenticate(ctx, clientID, secret)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("authenticate (korrekt): %v", err)
|
||||||
|
}
|
||||||
|
if !ok || moduleName != name {
|
||||||
|
t.Fatalf("erwartet erfolgreiche authentifizierung fuer %q, habe ok=%v moduleName=%q", name, ok, moduleName)
|
||||||
|
}
|
||||||
|
|
||||||
|
_, ok, err = registry.Authenticate(ctx, clientID, "falsches-secret")
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("authenticate (falsch): %v", err)
|
||||||
|
}
|
||||||
|
if ok {
|
||||||
|
t.Fatal("erwartet fehlschlag bei falschem secret")
|
||||||
|
}
|
||||||
|
|
||||||
|
_, ok, err = registry.Authenticate(ctx, "unbekannte-client-id", secret)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("authenticate (unbekannt): %v", err)
|
||||||
|
}
|
||||||
|
if ok {
|
||||||
|
t.Fatal("erwartet fehlschlag bei unbekannter client-id")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestProvision_RequiresRegisteredModule(t *testing.T) {
|
||||||
|
registry, _, cleanup := setupTest(t)
|
||||||
|
defer cleanup()
|
||||||
|
ctx := context.Background()
|
||||||
|
|
||||||
|
if _, _, err := registry.Provision(ctx, "nie-registriert"); !errors.Is(err, ErrModuleNotRegistered) {
|
||||||
|
t.Fatalf("erwartet ErrModuleNotRegistered, habe %v", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestRequireServiceCredential_RejectsInvalidAcceptsValid(t *testing.T) {
|
||||||
|
registry, _, cleanup := setupTest(t)
|
||||||
|
defer cleanup()
|
||||||
|
ctx := context.Background()
|
||||||
|
name := uniqueModuleName(t)
|
||||||
|
|
||||||
|
if _, err := registry.Register(ctx, name, "1.0", nil); err != nil {
|
||||||
|
t.Fatalf("register: %v", err)
|
||||||
|
}
|
||||||
|
clientID, secret, err := registry.Provision(ctx, name)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("provision: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
handler := registry.RequireServiceCredential(func(w http.ResponseWriter, r *http.Request) {
|
||||||
|
w.WriteHeader(http.StatusOK)
|
||||||
|
})
|
||||||
|
|
||||||
|
// Fehlendes Credential.
|
||||||
|
req := httptest.NewRequest(http.MethodPost, "/service-aufruf", nil)
|
||||||
|
rec := httptest.NewRecorder()
|
||||||
|
handler(rec, req)
|
||||||
|
if rec.Code != http.StatusUnauthorized {
|
||||||
|
t.Fatalf("ohne credential: status = %d, want 401", rec.Code)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Falsches Secret.
|
||||||
|
req2 := httptest.NewRequest(http.MethodPost, "/service-aufruf", nil)
|
||||||
|
req2.Header.Set("X-Client-Id", clientID)
|
||||||
|
req2.Header.Set("X-Client-Secret", "falsch")
|
||||||
|
rec2 := httptest.NewRecorder()
|
||||||
|
handler(rec2, req2)
|
||||||
|
if rec2.Code != http.StatusUnauthorized {
|
||||||
|
t.Fatalf("falsches secret: status = %d, want 401", rec2.Code)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Gueltiges Credential.
|
||||||
|
req3 := httptest.NewRequest(http.MethodPost, "/service-aufruf", nil)
|
||||||
|
req3.Header.Set("X-Client-Id", clientID)
|
||||||
|
req3.Header.Set("X-Client-Secret", secret)
|
||||||
|
rec3 := httptest.NewRecorder()
|
||||||
|
handler(rec3, req3)
|
||||||
|
if rec3.Code != http.StatusOK {
|
||||||
|
t.Fatalf("gueltiges credential: status = %d, want 200", rec3.Code)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,45 @@
|
|||||||
|
package tenant
|
||||||
|
|
||||||
|
import (
|
||||||
|
"encoding/json"
|
||||||
|
"net/http"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Handler ist eine schlanke Vorbereitung der Schnittstelle fuer API-01
|
||||||
|
// (REST-API-Grundgerüst & Versionierung) und TEN-02 (Self-Service-Onboarding).
|
||||||
|
// Auth/Rate-Limiting/Versionierung selbst sind ausdruecklich nicht Teil von
|
||||||
|
// TEN-01 und werden dort nachgezogen.
|
||||||
|
type Handler struct {
|
||||||
|
provisioner *Provisioner
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewHandler(p *Provisioner) *Handler {
|
||||||
|
return &Handler{provisioner: p}
|
||||||
|
}
|
||||||
|
|
||||||
|
type createTenantRequest struct {
|
||||||
|
Slug string `json:"slug"`
|
||||||
|
Name string `json:"name"`
|
||||||
|
}
|
||||||
|
|
||||||
|
func (h *Handler) CreateTenant(w http.ResponseWriter, r *http.Request) {
|
||||||
|
var req createTenantRequest
|
||||||
|
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||||||
|
http.Error(w, "ungueltige Anfrage", http.StatusBadRequest)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
t, err := h.provisioner.Provision(r.Context(), req.Slug, req.Name)
|
||||||
|
if err != nil {
|
||||||
|
if err == ErrInvalidSlug {
|
||||||
|
http.Error(w, err.Error(), http.StatusBadRequest)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
http.Error(w, "tenant konnte nicht angelegt werden", http.StatusInternalServerError)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
w.Header().Set("Content-Type", "application/json")
|
||||||
|
w.WriteHeader(http.StatusCreated)
|
||||||
|
_ = json.NewEncoder(w).Encode(t)
|
||||||
|
}
|
||||||
@@ -0,0 +1,78 @@
|
|||||||
|
package tenant
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"fmt"
|
||||||
|
|
||||||
|
"github.com/jackc/pgx/v5/pgxpool"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Provisioner legt fuer jeden neuen Mandanten eine vollstaendig isolierte
|
||||||
|
// PostgreSQL-Datenbank an und registriert sie transaktional in der Registry
|
||||||
|
// (Akzeptanzkriterium 2). Zwei Mandanten-Datenbanken sind danach auf
|
||||||
|
// Infrastrukturebene komplett getrennt (Akzeptanzkriterium 3).
|
||||||
|
type Provisioner struct {
|
||||||
|
// adminPool ist mit der Wartungsdatenbank (z. B. "postgres") verbunden
|
||||||
|
// und wird ausschliesslich fuer CREATE/DROP DATABASE verwendet, da diese
|
||||||
|
// Befehle in PostgreSQL nicht in einer Transaktion laufen koennen.
|
||||||
|
adminPool *pgxpool.Pool
|
||||||
|
registry *Registry
|
||||||
|
// dsnTemplate enthaelt genau ein "%s" als Platzhalter fuer den
|
||||||
|
// Datenbanknamen, z. B. "postgresql://user:pass@host:5432/%s?sslmode=disable".
|
||||||
|
dsnTemplate string
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewProvisioner(adminPool *pgxpool.Pool, registry *Registry, dsnTemplate string) *Provisioner {
|
||||||
|
return &Provisioner{adminPool: adminPool, registry: registry, dsnTemplate: dsnTemplate}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Provision legt die Tenant-Datenbank an und registriert sie. Schlaegt die
|
||||||
|
// Registrierung fehl, wird die bereits angelegte Datenbank wieder entfernt,
|
||||||
|
// damit kein verwaister, unregistrierter Tenant zurueckbleibt.
|
||||||
|
func (p *Provisioner) Provision(ctx context.Context, slug, name string) (Tenant, error) {
|
||||||
|
if err := ValidateSlug(slug); err != nil {
|
||||||
|
return Tenant{}, err
|
||||||
|
}
|
||||||
|
|
||||||
|
dbName := dbNameForSlug(slug)
|
||||||
|
|
||||||
|
// CREATE DATABASE erlaubt keine Parameter-Platzhalter; slug ist durch
|
||||||
|
// ValidateSlug bereits auf [a-z0-9_] beschraenkt, Injektion ausgeschlossen.
|
||||||
|
if _, err := p.adminPool.Exec(ctx, fmt.Sprintf(`CREATE DATABASE %q`, dbName)); err != nil {
|
||||||
|
return Tenant{}, fmt.Errorf("tenant-datenbank anlegen: %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
t := Tenant{
|
||||||
|
Slug: slug,
|
||||||
|
Name: name,
|
||||||
|
DBName: dbName,
|
||||||
|
DBDSN: fmt.Sprintf(p.dsnTemplate, dbName),
|
||||||
|
Status: StatusActive,
|
||||||
|
}
|
||||||
|
|
||||||
|
tx, err := p.registry.pool.Begin(ctx)
|
||||||
|
if err != nil {
|
||||||
|
p.rollbackDatabase(ctx, dbName)
|
||||||
|
return Tenant{}, fmt.Errorf("registry-transaktion starten: %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
created, err := p.registry.insertTx(ctx, tx, t)
|
||||||
|
if err != nil {
|
||||||
|
_ = tx.Rollback(ctx)
|
||||||
|
p.rollbackDatabase(ctx, dbName)
|
||||||
|
return Tenant{}, err
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := tx.Commit(ctx); err != nil {
|
||||||
|
p.rollbackDatabase(ctx, dbName)
|
||||||
|
return Tenant{}, fmt.Errorf("registry-transaktion committen: %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
return created, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// rollbackDatabase entfernt eine bereits angelegte Tenant-Datenbank, wenn die
|
||||||
|
// Registrierung fehlschlug, damit Provisioning insgesamt atomar wirkt.
|
||||||
|
func (p *Provisioner) rollbackDatabase(ctx context.Context, dbName string) {
|
||||||
|
_, _ = p.adminPool.Exec(ctx, fmt.Sprintf(`DROP DATABASE IF EXISTS %q`, dbName))
|
||||||
|
}
|
||||||
@@ -0,0 +1,105 @@
|
|||||||
|
package tenant
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"os"
|
||||||
|
"strings"
|
||||||
|
"testing"
|
||||||
|
|
||||||
|
"github.com/jackc/pgx/v5/pgxpool"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Integrationstest fuer Akzeptanzkriterien 2 und 3. Benoetigt eine echte
|
||||||
|
// Postgres-Instanz und wird ohne TEST_ADMIN_DSN uebersprungen, nicht als
|
||||||
|
// fehlgeschlagen gewertet — siehe Pruefungen-Ergebnis im PR.
|
||||||
|
//
|
||||||
|
// TEST_ADMIN_DSN muss auf die Wartungsdatenbank zeigen, z. B.:
|
||||||
|
//
|
||||||
|
// postgresql://postgres:postgres@localhost:5432/postgres?sslmode=disable
|
||||||
|
func TestProvision_CreatesIsolatedDatabases(t *testing.T) {
|
||||||
|
adminDSN := os.Getenv("TEST_ADMIN_DSN")
|
||||||
|
if adminDSN == "" {
|
||||||
|
t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
|
||||||
|
}
|
||||||
|
ctx := context.Background()
|
||||||
|
|
||||||
|
adminPool, err := pgxpool.New(ctx, adminDSN)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("admin pool: %v", err)
|
||||||
|
}
|
||||||
|
defer adminPool.Close()
|
||||||
|
|
||||||
|
registryPool, err := pgxpool.New(ctx, adminDSN)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("registry pool: %v", err)
|
||||||
|
}
|
||||||
|
defer registryPool.Close()
|
||||||
|
|
||||||
|
if _, err := registryPool.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()
|
||||||
|
)`); err != nil {
|
||||||
|
t.Fatalf("registry-schema: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
dsnTemplate := strings.Replace(adminDSN, "/postgres?", "/%s?", 1)
|
||||||
|
registry := NewRegistry(registryPool)
|
||||||
|
provisioner := NewProvisioner(adminPool, registry, dsnTemplate)
|
||||||
|
|
||||||
|
t.Cleanup(func() {
|
||||||
|
_, _ = registryPool.Exec(ctx, `DELETE FROM tenants WHERE slug IN ('acme','globex')`)
|
||||||
|
_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_acme`)
|
||||||
|
_, _ = adminPool.Exec(ctx, `DROP DATABASE IF EXISTS tenant_globex`)
|
||||||
|
})
|
||||||
|
|
||||||
|
tenantA, err := provisioner.Provision(ctx, "acme", "Acme GmbH")
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("provision acme: %v", err)
|
||||||
|
}
|
||||||
|
tenantB, err := provisioner.Provision(ctx, "globex", "Globex AG")
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("provision globex: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if tenantA.DBName == tenantB.DBName {
|
||||||
|
t.Fatalf("erwartet unterschiedliche db_name, beide sind %q", tenantA.DBName)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Akzeptanzkriterium 3 / Pruefung 3: In der Datenbank von Tenant A existiert
|
||||||
|
// keine Verbindungsmoeglichkeit zu Tenant B, weil beide physisch getrennte
|
||||||
|
// Datenbanken sind, statt sich auf einen Query-Filter zu verlassen.
|
||||||
|
poolA, err := pgxpool.New(ctx, tenantA.DBDSN)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("connect tenant a: %v", err)
|
||||||
|
}
|
||||||
|
defer poolA.Close()
|
||||||
|
|
||||||
|
var globexVisible bool
|
||||||
|
err = poolA.QueryRow(ctx, `
|
||||||
|
SELECT EXISTS (
|
||||||
|
SELECT 1 FROM pg_catalog.pg_database WHERE datname = $1
|
||||||
|
)
|
||||||
|
`, tenantB.DBName).Scan(&globexVisible)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("pruefung tenant-trennung: %v", err)
|
||||||
|
}
|
||||||
|
// pg_database ist clusterweit sichtbar (Existenz der DB), aber die
|
||||||
|
// eigentliche Pruefung ist: aus poolA (verbunden mit tenant_acme) ist keine
|
||||||
|
// Tabelle/Zeile aus tenant_globex erreichbar, da current_database() getrennt ist.
|
||||||
|
var currentDB string
|
||||||
|
if err := poolA.QueryRow(ctx, `SELECT current_database()`).Scan(¤tDB); err != nil {
|
||||||
|
t.Fatalf("current_database: %v", err)
|
||||||
|
}
|
||||||
|
if currentDB != tenantA.DBName {
|
||||||
|
t.Fatalf("current_database() = %q, want %q — keine physische Trennung", currentDB, tenantA.DBName)
|
||||||
|
}
|
||||||
|
if currentDB == tenantB.DBName {
|
||||||
|
t.Fatalf("tenant a verbindung zeigt auf tenant b datenbank")
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,69 @@
|
|||||||
|
package tenant
|
||||||
|
|
||||||
|
import (
|
||||||
|
"context"
|
||||||
|
"fmt"
|
||||||
|
|
||||||
|
"github.com/jackc/pgx/v5"
|
||||||
|
"github.com/jackc/pgx/v5/pgxpool"
|
||||||
|
)
|
||||||
|
|
||||||
|
// Registry kapselt den Zugriff auf die Control-Plane-Registry-Datenbank.
|
||||||
|
// Sie enthaelt ausschliesslich Tenant-Metadaten (Akzeptanzkriterium 1) —
|
||||||
|
// niemals Geschaeftsdaten eines Mandanten.
|
||||||
|
type Registry struct {
|
||||||
|
pool *pgxpool.Pool
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewRegistry(pool *pgxpool.Pool) *Registry {
|
||||||
|
return &Registry{pool: pool}
|
||||||
|
}
|
||||||
|
|
||||||
|
// insertTx schreibt den Tenant-Datensatz innerhalb einer laufenden Transaktion,
|
||||||
|
// damit Provisioner.Provision DB-Anlage und Registrierung atomar behandeln kann.
|
||||||
|
func (r *Registry) insertTx(ctx context.Context, tx pgx.Tx, t Tenant) (Tenant, error) {
|
||||||
|
row := tx.QueryRow(ctx, `
|
||||||
|
INSERT INTO tenants (slug, name, db_name, db_dsn, status)
|
||||||
|
VALUES ($1, $2, $3, $4, $5)
|
||||||
|
RETURNING id, created_at
|
||||||
|
`, t.Slug, t.Name, t.DBName, t.DBDSN, t.Status)
|
||||||
|
|
||||||
|
if err := row.Scan(&t.ID, &t.CreatedAt); err != nil {
|
||||||
|
return Tenant{}, fmt.Errorf("tenant registrieren: %w", err)
|
||||||
|
}
|
||||||
|
return t, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *Registry) GetBySlug(ctx context.Context, slug string) (Tenant, error) {
|
||||||
|
var t Tenant
|
||||||
|
row := r.pool.QueryRow(ctx, `
|
||||||
|
SELECT id, slug, name, db_name, db_dsn, status, created_at
|
||||||
|
FROM tenants WHERE slug = $1
|
||||||
|
`, slug)
|
||||||
|
|
||||||
|
if err := row.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
|
||||||
|
return Tenant{}, fmt.Errorf("tenant laden: %w", err)
|
||||||
|
}
|
||||||
|
return t, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *Registry) List(ctx context.Context) ([]Tenant, error) {
|
||||||
|
rows, err := r.pool.Query(ctx, `
|
||||||
|
SELECT id, slug, name, db_name, db_dsn, status, created_at
|
||||||
|
FROM tenants ORDER BY created_at
|
||||||
|
`)
|
||||||
|
if err != nil {
|
||||||
|
return nil, fmt.Errorf("tenants auflisten: %w", err)
|
||||||
|
}
|
||||||
|
defer rows.Close()
|
||||||
|
|
||||||
|
var out []Tenant
|
||||||
|
for rows.Next() {
|
||||||
|
var t Tenant
|
||||||
|
if err := rows.Scan(&t.ID, &t.Slug, &t.Name, &t.DBName, &t.DBDSN, &t.Status, &t.CreatedAt); err != nil {
|
||||||
|
return nil, fmt.Errorf("tenant lesen: %w", err)
|
||||||
|
}
|
||||||
|
out = append(out, t)
|
||||||
|
}
|
||||||
|
return out, rows.Err()
|
||||||
|
}
|
||||||
@@ -0,0 +1,42 @@
|
|||||||
|
// Package tenant implements Core TEN-01: die Control-Plane-Registry und die
|
||||||
|
// Provisioning-Routine fuer physisch getrennte Mandanten-Datenbanken (Modell C).
|
||||||
|
package tenant
|
||||||
|
|
||||||
|
import (
|
||||||
|
"errors"
|
||||||
|
"regexp"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
type Status string
|
||||||
|
|
||||||
|
const (
|
||||||
|
StatusActive Status = "active"
|
||||||
|
)
|
||||||
|
|
||||||
|
type Tenant struct {
|
||||||
|
ID string
|
||||||
|
Slug string
|
||||||
|
Name string
|
||||||
|
DBName string
|
||||||
|
DBDSN string
|
||||||
|
Status Status
|
||||||
|
CreatedAt time.Time
|
||||||
|
}
|
||||||
|
|
||||||
|
// slugPattern erzwingt sichere, als SQL-Identifier verwendbare Slugs, damit
|
||||||
|
// der Datenbankname niemals aus unkontrolliertem Nutzereingabe-Text gebaut wird.
|
||||||
|
var slugPattern = regexp.MustCompile(`^[a-z][a-z0-9_]{1,48}$`)
|
||||||
|
|
||||||
|
var ErrInvalidSlug = errors.New("tenant: slug muss mit Kleinbuchstaben beginnen und darf nur [a-z0-9_] enthalten (2-49 Zeichen)")
|
||||||
|
|
||||||
|
func ValidateSlug(slug string) error {
|
||||||
|
if !slugPattern.MatchString(slug) {
|
||||||
|
return ErrInvalidSlug
|
||||||
|
}
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func dbNameForSlug(slug string) string {
|
||||||
|
return "tenant_" + slug
|
||||||
|
}
|
||||||
@@ -0,0 +1,35 @@
|
|||||||
|
package tenant
|
||||||
|
|
||||||
|
import "testing"
|
||||||
|
|
||||||
|
func TestValidateSlug(t *testing.T) {
|
||||||
|
cases := []struct {
|
||||||
|
slug string
|
||||||
|
wantErr bool
|
||||||
|
}{
|
||||||
|
{"acme", false},
|
||||||
|
{"acme_gmbh", false},
|
||||||
|
{"a1", false},
|
||||||
|
{"", true},
|
||||||
|
{"a", true},
|
||||||
|
{"1acme", true},
|
||||||
|
{"Acme", true},
|
||||||
|
{"acme-gmbh", true},
|
||||||
|
{"acme;drop table tenants", true},
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, c := range cases {
|
||||||
|
err := ValidateSlug(c.slug)
|
||||||
|
if (err != nil) != c.wantErr {
|
||||||
|
t.Errorf("ValidateSlug(%q) error = %v, wantErr %v", c.slug, err, c.wantErr)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestDBNameForSlug(t *testing.T) {
|
||||||
|
got := dbNameForSlug("acme")
|
||||||
|
want := "tenant_acme"
|
||||||
|
if got != want {
|
||||||
|
t.Errorf("dbNameForSlug() = %q, want %q", got, want)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1 @@
|
|||||||
|
DROP TABLE IF EXISTS tenants;
|
||||||
@@ -1,10 +0,0 @@
|
|||||||
-- Control-plane registry: tenant list + connection info (Modell C).
|
|
||||||
-- Core TEN-01 (siehe core-kanban).
|
|
||||||
CREATE TABLE tenants (
|
|
||||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
|
||||||
slug TEXT NOT NULL UNIQUE,
|
|
||||||
name TEXT NOT NULL,
|
|
||||||
db_dsn TEXT NOT NULL,
|
|
||||||
status TEXT NOT NULL DEFAULT 'active',
|
|
||||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
|
||||||
);
|
|
||||||
@@ -0,0 +1,14 @@
|
|||||||
|
-- Control-plane registry: Tenant-Liste + Verbindungsinformationen (Modell C).
|
||||||
|
-- Enthaelt AUSSCHLIESSLICH Tenant-Metadaten, keine Geschaeftsdaten eines Mandanten.
|
||||||
|
-- Core TEN-01 (siehe core-kanban/tickets/TEN-01.md).
|
||||||
|
CREATE EXTENSION IF NOT EXISTS pgcrypto;
|
||||||
|
|
||||||
|
CREATE TABLE 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()
|
||||||
|
);
|
||||||
@@ -0,0 +1 @@
|
|||||||
|
DROP TABLE IF EXISTS feature_flags;
|
||||||
@@ -0,0 +1,10 @@
|
|||||||
|
-- Feature-Flags zentral je Mandant/Zielgruppe (LIC-02, siehe core-kanban/tickets/LIC-02.md).
|
||||||
|
-- Lebt in der Registry-DB, nicht pro Tenant-Datenbank — Flags sind eine
|
||||||
|
-- Core-weite Konfiguration, keine Mandanten-Geschaeftsdaten.
|
||||||
|
CREATE TABLE feature_flags (
|
||||||
|
key TEXT PRIMARY KEY,
|
||||||
|
enabled BOOLEAN NOT NULL DEFAULT false,
|
||||||
|
rollout_percentage INT NOT NULL DEFAULT 0 CHECK (rollout_percentage BETWEEN 0 AND 100),
|
||||||
|
target_tenant_slugs TEXT[] NOT NULL DEFAULT '{}',
|
||||||
|
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||||
|
);
|
||||||
@@ -0,0 +1,2 @@
|
|||||||
|
DROP TABLE IF EXISTS module_credentials;
|
||||||
|
DROP TABLE IF EXISTS modules;
|
||||||
@@ -0,0 +1,18 @@
|
|||||||
|
-- Modul-Registry & Aktivierungspruefung (API-02, siehe core-kanban/tickets/API-02.md).
|
||||||
|
CREATE TABLE modules (
|
||||||
|
name TEXT PRIMARY KEY,
|
||||||
|
version TEXT NOT NULL CHECK (version <> ''),
|
||||||
|
required_flags TEXT[] NOT NULL DEFAULT '{}',
|
||||||
|
registered_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||||
|
);
|
||||||
|
|
||||||
|
-- Service-Credential je Modul-Instanz, bei Provisionierung ausgestellt
|
||||||
|
-- (Akzeptanzkriterium 4). secret_hash enthaelt NIEMALS das Secret im
|
||||||
|
-- Klartext, nur dessen SHA-256-Hash (Timing-safe-Vergleich beim Login,
|
||||||
|
-- Referenzmuster siehe AUD-02).
|
||||||
|
CREATE TABLE 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()
|
||||||
|
);
|
||||||
@@ -0,0 +1 @@
|
|||||||
|
DROP TABLE tenant_keks;
|
||||||
@@ -0,0 +1,10 @@
|
|||||||
|
-- Master-Key-Verwaltung & Tenant-Schluesselhierarchie (API-10, siehe
|
||||||
|
-- core-kanban/tickets/API-10.md) — EIN verpackter (mit dem Master-Key
|
||||||
|
-- umhuellter) Tenant-KEK je Mandant. Niemals der Master-Key selbst und
|
||||||
|
-- niemals ein Tenant-KEK im Klartext in dieser Tabelle.
|
||||||
|
CREATE TABLE tenant_keks (
|
||||||
|
tenant_id UUID PRIMARY KEY REFERENCES tenants(id),
|
||||||
|
wrapped_kek BYTEA NOT NULL,
|
||||||
|
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||||
|
rotated_at TIMESTAMPTZ
|
||||||
|
);
|
||||||
Executable
+23
@@ -0,0 +1,23 @@
|
|||||||
|
#!/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;"
|
||||||
|
|
||||||
|
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."
|
||||||
Executable
+24
@@ -0,0 +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
|
||||||
Reference in New Issue
Block a user