software steht so weit.

jetzt build + docker build und testen

pkg/server/server_test.go

@@ -3,6 +3,7 @@ package server
 import (
 	"bytes"
 	"context"
+	"crypto/ed25519"
 	"encoding/json"
 	"errors"
 	"io"
@@ -10,6 +11,7 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
+	"reflect"
 	"strings"
 	"sync"
 	"testing"
@@ -17,6 +19,8 @@ import (
 
 	"sultan/pkg/auth"
 	"sultan/pkg/crypto"
+	"sultan/pkg/license"
+	"sultan/pkg/notify"
 	"sultan/pkg/policy"
 	"sultan/pkg/registry"
 	"sultan/pkg/store"
@@ -58,6 +62,7 @@ func startServer(t *testing.T, mutate ...func(*Config)) (*Server, *syncBuffer) {
 		DataDir:         filepath.Join(t.TempDir(), "suldata"),
 		AgentAddr:       "127.0.0.1:0",
 		ProviderAddr:    "127.0.0.1:0",
+		LanderAddr:      "127.0.0.1:0",
 		RefreshInterval: time.Hour,
 		Logger:          slog.New(slog.NewTextHandler(logs, nil)),
 	}
@@ -92,7 +97,7 @@ func createTenant(t *testing.T, s *Server, id string, domains ...string) {
 // issueToken erzeugt einen Enrollment-Token wie `sultan token` es tun wird.
 func issueToken(t *testing.T, s *Server, tenant string) string {
 	t.Helper()
-	tok, err := crypto.NewEnrollmentToken(s.Fingerprint())
+	tok, err := crypto.NewEnrollmentToken(s.Fingerprint(), "")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -116,11 +121,10 @@ func newAgent(t *testing.T, s *Server, token string) *testAgent {
 	if err != nil {
 		t.Fatal(err)
 	}
-	ks := &crypto.KnownServers{Path: filepath.Join(t.TempDir(), "known_servers")}
 	priv, _ := auth.GenerateKey()
 	return &testAgent{
 		base:   "https://" + s.AgentAddr(),
-		hc:     &http.Client{Transport: &http.Transport{TLSClientConfig: crypto.ClientTLSConfig(s.AgentAddr(), ks, tok.Fingerprint)}},
+		hc:     &http.Client{Transport: &http.Transport{TLSClientConfig: crypto.PinnedTLSConfig(tok.Fingerprint)}},
 		signer: &auth.Signer{Key: priv},
 		secret: tok.Secret,
 	}
@@ -151,13 +155,46 @@ func (a *testAgent) enroll(t *testing.T, nodeID string) *http.Response {
 
 // connect hält den Stream im Hintergrund offen, bis cancel aufgerufen wird.
 func (a *testAgent) connect(t *testing.T) (cancel func()) {
+	t.Helper()
+	cancel, _ = a.connectEvents(t)
+	return cancel
+}
+
+// connectEvents hält den Stream offen und liefert die empfangenen Events.
+func (a *testAgent) connectEvents(t *testing.T) (cancel func(), events <-chan stream.Event) {
 	t.Helper()
 	sctx, cancel := context.WithCancel(ctx)
+	ch := make(chan stream.Event, 64)
 	c := &stream.Client{URL: a.base + "/api/v1/stream", HTTPClient: a.hc, Prepare: a.signer.Sign, MinBackoff: 10 * time.Millisecond}
 	done := make(chan struct{})
-	go func() { c.Run(sctx, func(stream.Event) error { return nil }); close(done) }()
+	go func() {
+		c.Run(sctx, func(ev stream.Event) error {
+			select {
+			case ch <- ev:
+			default:
+			}
+			return nil
+		})
+		close(done)
+	}()
 	t.Cleanup(func() { cancel(); <-done })
-	return cancel
+	return cancel, ch
+}
+
+// nextEvent wartet auf das nächste Event des Typs typ.
+func nextEvent(t *testing.T, events <-chan stream.Event, typ stream.EventType) stream.Event {
+	t.Helper()
+	deadline := time.After(3 * time.Second)
+	for {
+		select {
+		case ev := <-events:
+			if ev.Type == typ {
+				return ev
+			}
+		case <-deadline:
+			t.Fatalf("kein Event %s empfangen", typ)
+		}
+	}
 }
 
 func wpState(domain string) registry.NodeState {
@@ -187,7 +224,7 @@ func TestConfigDefaults(t *testing.T) {
 	if c.DataDir != "./suldata" || c.AgentAddr != ":8443" || c.ProviderAddr != "127.0.0.1:8080" {
 		t.Errorf("Defaults: %+v", c)
 	}
-	if c.InterceptorURL != "http://127.0.0.1:8081" || c.RefreshInterval != time.Minute || c.Logger == nil {
+	if c.InterceptorURL != "http://127.0.0.1:8081" || c.LanderAddr != "127.0.0.1:8081" || c.RefreshInterval != time.Minute || c.Logger == nil {
 		t.Errorf("Defaults: %+v", c)
 	}
 }
@@ -299,8 +336,11 @@ func TestEndToEnd(t *testing.T) {
 		t.Errorf("Traefik-Konfiguration: %s", cfg)
 	}
 
+	// Ungeplant getrennt: Routen bleiben als Wartungsseite, solange die Lease gilt.
 	stop()
-	eventually(t, "Route nach Trennung entfernt", func() bool { return providerConfig(t, s) == "{}" })
+	eventually(t, "Wartungsseite nach Trennung", func() bool {
+		return strings.Contains(providerConfig(t, s), policy.InterceptorService)
+	})
 	eventually(t, "Knoten offline", func() bool {
 		n, _ := s.store.GetNode(ctx, "node-1")
 		return n.Status == store.NodeOffline
@@ -442,7 +482,7 @@ func TestDirectory(t *testing.T) {
 func TestRun_ShutdownWithOpenStream(t *testing.T) {
 	cfg := Config{
 		DataDir: filepath.Join(t.TempDir(), "suldata"), AgentAddr: "127.0.0.1:0", ProviderAddr: "127.0.0.1:0",
-		Logger: slog.New(slog.DiscardHandler),
+		LanderAddr: "127.0.0.1:0", Logger: slog.New(slog.DiscardHandler),
 	}
 	s, err := New(ctx, cfg)
 	if err != nil {
@@ -474,7 +514,7 @@ func TestStart_PortInUse(t *testing.T) {
 	a, _ := startServer(t)
 	b, err := New(ctx, Config{
 		DataDir: filepath.Join(t.TempDir(), "suldata"), AgentAddr: a.AgentAddr(), ProviderAddr: "127.0.0.1:0",
-		Logger: slog.New(slog.DiscardHandler),
+		LanderAddr: "127.0.0.1:0", Logger: slog.New(slog.DiscardHandler),
 	})
 	if err != nil {
 		t.Fatal(err)
@@ -484,3 +524,679 @@ func TestStart_PortInUse(t *testing.T) {
 		t.Error("belegter Port: erwartet Fehler")
 	}
 }
+
+// Wie Traefik: Konfiguration lesen, Router zum Interceptor finden, dessen
+// Header-Middleware anwenden und den Lander aufrufen.
+func TestLander_EndToEndMaintenance(t *testing.T) {
+	s, _ := startServer(t, func(c *Config) { c.ProURL = "https://hoster.example/pro" })
+	if s.LanderAddr() == "" || strings.HasSuffix(s.LanderAddr(), ":0") {
+		t.Fatalf("Lander-Adresse: %q", s.LanderAddr())
+	}
+	createTenant(t, s, "kunde", "kunde.de")
+	agent := newAgent(t, s, issueToken(t, s, "kunde"))
+	agent.enroll(t, "n1")
+	agent.connect(t)
+	eventually(t, "Stream", func() bool { return s.hub.Connected("n1") })
+	st := wpState("kunde.de")
+	st.DownServices = []string{"wp"}
+	if r := agent.do(t, http.MethodPost, "/api/v1/state", st); r.StatusCode != http.StatusNoContent {
+		t.Fatalf("State: %d", r.StatusCode)
+	}
+
+	var cfg struct {
+		HTTP struct {
+			Routers map[string]struct {
+				Service     string
+				Middlewares []string
+			}
+			Services map[string]struct {
+				LoadBalancer struct{ Servers []struct{ URL string } }
+			}
+			Middlewares map[string]struct {
+				Headers struct{ CustomRequestHeaders map[string]string }
+			}
+		}
+	}
+	if err := json.Unmarshal([]byte(providerConfig(t, s)), &cfg); err != nil {
+		t.Fatal(err)
+	}
+	router := cfg.HTTP.Routers["kunde__n1__wp"]
+	interceptor := cfg.HTTP.Services[router.Service].LoadBalancer.Servers[0].URL
+	if interceptor != "http://"+s.LanderAddr() {
+		t.Fatalf("Interceptor-URL %q, erwartet den gebundenen Lander %q", interceptor, s.LanderAddr())
+	}
+	req, _ := http.NewRequest(http.MethodGet, interceptor+"/shop", nil)
+	for _, mw := range router.Middlewares {
+		for k, v := range cfg.HTTP.Middlewares[mw].Headers.CustomRequestHeaders {
+			req.Header.Set(k, v)
+		}
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != http.StatusServiceUnavailable || resp.Header.Get("Retry-After") != "60" ||
+		!strings.Contains(string(body), "Gleich wieder da") {
+		t.Errorf("Lander: %d %q\n%s", resp.StatusCode, resp.Header.Get("Retry-After"), body)
+	}
+}
+
+func TestLander_CustomTemplatesFromDataDir(t *testing.T) {
+	s, _ := startServer(t)
+	dir := filepath.Join(s.cfg.DataDir, "landing")
+	os.MkdirAll(dir, 0o755)
+	os.WriteFile(filepath.Join(dir, "maintenance.html"), []byte("Eigene Seite {{.Tenant}}"), 0o644)
+	req, _ := http.NewRequest(http.MethodGet, "http://"+s.LanderAddr()+"/", nil)
+	req.Header.Set("X-Sultan-Stage", "maintenance")
+	req.Header.Set("X-Sultan-Tenant", "kunde")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	if body, _ := io.ReadAll(resp.Body); string(body) != "Eigene Seite kunde" {
+		t.Errorf("body = %q", body)
+	}
+}
+
+func TestLander_Disabled(t *testing.T) {
+	s, _ := startServer(t, func(c *Config) { c.LanderAddr = "none"; c.InterceptorURL = "http://lander.intern:8081" })
+	if s.LanderAddr() != "" {
+		t.Errorf("Lander läuft trotz none: %q", s.LanderAddr())
+	}
+	if s.registry.Policy.InterceptorURL != "http://lander.intern:8081" {
+		t.Errorf("explizite Interceptor-URL überschrieben: %q", s.registry.Policy.InterceptorURL)
+	}
+}
+
+// Die öffentliche Adresse wird im Store gemerkt, damit `sultan token invite`
+// (eigener Prozess) sie in Einladungen einbetten kann.
+func TestPublicURLs(t *testing.T) {
+	dir := filepath.Join(t.TempDir(), "suldata")
+	discard := slog.New(slog.DiscardHandler)
+	if _, err := New(ctx, Config{DataDir: dir, PublicURLs: []string{"https://ok.example:8443", "http://ingress:8443"}, Logger: discard}); err == nil {
+		t.Error("http-URL akzeptiert")
+	}
+	s, err := New(ctx, Config{DataDir: dir, PublicURLs: []string{"https://Ingress.example:8443/", "https://100.64.0.1:8443"}, Logger: discard})
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []string{"https://ingress.example:8443", "https://100.64.0.1:8443"}
+	if got, err := s.PublicURLs(ctx); err != nil || !reflect.DeepEqual(got, want) {
+		t.Errorf("gespeichert: %v %v", got, err)
+	}
+	s.Shutdown(ctx)
+
+	// Neustart ohne --public-url: gemerkte Adressen bleiben.
+	s, err = New(ctx, Config{DataDir: dir, Logger: discard})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer s.Shutdown(ctx)
+	if got, _ := s.PublicURLs(ctx); !reflect.DeepEqual(got, want) {
+		t.Errorf("nach Neustart: %v", got)
+	}
+}
+
+// Beim Verbinden bekommt der Agent die vollständige Adressliste (signiert).
+func TestConfigCommandOnConnect(t *testing.T) {
+	urls := []string{"https://ingress.example:8443", "https://100.64.0.1:8443"}
+	s, _ := startServer(t, func(c *Config) { c.PublicURLs = urls })
+	createTenant(t, s, "kunde", "kunde.de")
+	agent := newAgent(t, s, issueToken(t, s, "kunde"))
+	agent.enroll(t, "n1")
+	_, events := agent.connectEvents(t)
+
+	ev := nextEvent(t, events, stream.EventNodeCommand)
+	if err := stream.VerifyEvent(ev, s.MasterPublicKey()); err != nil {
+		t.Fatal(err)
+	}
+	cmd, err := stream.ParseNodeCommand(ev)
+	if err != nil || cmd.Command != stream.CmdConfig || !reflect.DeepEqual(cmd.ServerURLs, urls) {
+		t.Errorf("config-Befehl: %+v %v", cmd, err)
+	}
+}
+
+func TestNoConfigCommandWithoutPublicURLs(t *testing.T) {
+	s, _ := startServer(t)
+	createTenant(t, s, "kunde", "kunde.de")
+	agent := newAgent(t, s, issueToken(t, s, "kunde"))
+	agent.enroll(t, "n1")
+	_, events := agent.connectEvents(t)
+	nextEvent(t, events, stream.EventLeaseRenew)
+	select {
+	case ev := <-events:
+		if ev.Type == stream.EventNodeCommand {
+			t.Errorf("config ohne Adressen gesendet: %s", ev.Payload)
+		}
+	case <-time.After(200 * time.Millisecond):
+	}
+}
+
+// connectedAgent: enrollt, verbindet und meldet wpState(kunde.de).
+func connectedAgent(t *testing.T, s *Server, node string) (*testAgent, func()) {
+	t.Helper()
+	if _, err := s.store.GetTenant(ctx, "kunde"); err != nil {
+		createTenant(t, s, "kunde", "kunde.de")
+	}
+	agent := newAgent(t, s, issueToken(t, s, "kunde"))
+	if r := agent.enroll(t, node); r.StatusCode != http.StatusCreated {
+		t.Fatalf("Enrollment: %d", r.StatusCode)
+	}
+	stop := agent.connect(t)
+	eventually(t, "Stream", func() bool { return s.hub.Connected(node) })
+	if r := agent.do(t, http.MethodPost, "/api/v1/state", wpState("kunde.de")); r.StatusCode != http.StatusNoContent {
+		t.Fatalf("State: %d", r.StatusCode)
+	}
+	return agent, stop
+}
+
+func TestMaintenance_AgentEndpoint(t *testing.T) {
+	s, logs := startServer(t)
+	agent, _ := connectedAgent(t, s, "n1")
+
+	resp := agent.do(t, http.MethodPost, "/api/v1/maintenance", MaintenanceRequest{
+		Enabled: true, Duration: "2h", Reason: "Kernel 6.12", PublicReason: "Sicherheitsupdate",
+	})
+	if resp.StatusCode != http.StatusNoContent {
+		b, _ := io.ReadAll(resp.Body)
+		t.Fatalf("Wartung an: %d %s", resp.StatusCode, b)
+	}
+	n, _ := s.store.GetNode(ctx, "n1")
+	if m := n.Maintenance; m == nil || m.Reason != "Kernel 6.12" || m.PublicReason != "Sicherheitsupdate" ||
+		time.Until(m.Until) < 119*time.Minute || time.Until(m.Until) > 121*time.Minute {
+		t.Errorf("gespeichert: %+v", m)
+	}
+	// Sofort wirksam, nicht erst beim nächsten Refresh.
+	if cfg := providerConfig(t, s); !strings.Contains(cfg, policy.InterceptorService) {
+		t.Errorf("Wartung nicht sofort wirksam: %s", cfg)
+	}
+	if !strings.Contains(logs.String(), "Kernel 6.12") {
+		t.Error("interner Grund nicht protokolliert")
+	}
+
+	if r := agent.do(t, http.MethodPost, "/api/v1/maintenance", MaintenanceRequest{Enabled: false}); r.StatusCode != http.StatusNoContent {
+		t.Fatalf("Wartung aus: %d", r.StatusCode)
+	}
+	if n, _ := s.store.GetNode(ctx, "n1"); n.Maintenance != nil {
+		t.Error("Wartung nicht beendet")
+	}
+	if cfg := providerConfig(t, s); strings.Contains(cfg, policy.InterceptorService) {
+		t.Errorf("nach Wartungsende noch umgeleitet: %s", cfg)
+	}
+}
+
+func TestMaintenance_DefaultAndUnlimited(t *testing.T) {
+	s, _ := startServer(t)
+	agent, _ := connectedAgent(t, s, "n1")
+
+	agent.do(t, http.MethodPost, "/api/v1/maintenance", MaintenanceRequest{Enabled: true})
+	n, _ := s.store.GetNode(ctx, "n1")
+	if d := time.Until(n.Maintenance.Until); d < 239*time.Minute || d > 241*time.Minute {
+		t.Errorf("Default-Dauer %v, erwartet 4h", d)
+	}
+	agent.do(t, http.MethodPost, "/api/v1/maintenance", MaintenanceRequest{Enabled: true, Duration: "0"})
+	if n, _ := s.store.GetNode(ctx, "n1"); n.Maintenance == nil || !n.Maintenance.Until.IsZero() {
+		t.Errorf("Dauer 0 = unbefristet: %+v", n.Maintenance)
+	}
+}
+
+func TestMaintenance_InvalidRequests(t *testing.T) {
+	s, _ := startServer(t)
+	agent, _ := connectedAgent(t, s, "n1")
+	for name, req := range map[string]any{
+		"Dauer unlesbar":   MaintenanceRequest{Enabled: true, Duration: "bald"},
+		"Dauer negativ":    MaintenanceRequest{Enabled: true, Duration: "-1h"},
+		"Grund zu lang":    MaintenanceRequest{Enabled: true, PublicReason: strings.Repeat("x", 301)},
+		"Grund mehrzeilig": MaintenanceRequest{Enabled: true, PublicReason: "Zeile 1\nZeile 2"},
+		"kein JSON-Objekt": "an",
+	} {
+		if r := agent.do(t, http.MethodPost, "/api/v1/maintenance", req); r.StatusCode != http.StatusBadRequest {
+			t.Errorf("%s: Status %d", name, r.StatusCode)
+		}
+	}
+	plain, _ := http.NewRequest(http.MethodPost, agent.base+"/api/v1/maintenance", strings.NewReader(`{"enabled":true}`))
+	if resp, err := agent.hc.Do(plain); err != nil || resp.StatusCode != http.StatusUnauthorized {
+		t.Errorf("unsigniert: %v %v", resp, err)
+	}
+}
+
+// Reboot während der Wartung: Routen bleiben als Wartungsseite stehen, bis
+// die Wartung endet – erst dann verschwinden sie.
+func TestMaintenance_DisconnectKeepsRoutesUntilEnd(t *testing.T) {
+	// Kurze Lease, damit nach Wartungsende nicht die Lease die Routen hält.
+	s, _ := startServer(t, func(c *Config) { c.RefreshInterval = 20 * time.Millisecond; c.LeaseDuration = 150 * time.Millisecond })
+	agent, stop := connectedAgent(t, s, "n1")
+	agent.do(t, http.MethodPost, "/api/v1/maintenance", MaintenanceRequest{Enabled: true, Duration: "400ms"})
+
+	stop()
+	eventually(t, "Knoten getrennt", func() bool { return !s.hub.Connected("n1") })
+	time.Sleep(100 * time.Millisecond) // einige Refresh-Runden
+	if cfg := providerConfig(t, s); !strings.Contains(cfg, policy.InterceptorService) {
+		t.Fatalf("Routen während der Wartung entfernt: %s", cfg)
+	}
+	eventually(t, "Routen nach Wartungsende entfernt", func() bool { return providerConfig(t, s) == "{}" })
+}
+
+// Per CLI (anderer Prozess, direkt im Store) gesetzte Wartung wirkt beim nächsten Refresh.
+func TestMaintenance_FromStoreAppliedOnRefresh(t *testing.T) {
+	s, _ := startServer(t, func(c *Config) { c.RefreshInterval = 20 * time.Millisecond })
+	connectedAgent(t, s, "n1")
+	if err := s.store.SetNodeMaintenance(ctx, "n1", store.Maintenance{Until: time.Now().Add(time.Hour)}); err != nil {
+		t.Fatal(err)
+	}
+	eventually(t, "Umleitung", func() bool { return strings.Contains(providerConfig(t, s), policy.InterceptorService) })
+}
+
+func TestDirectory_Maintenance(t *testing.T) {
+	s, _ := startServer(t)
+	createTenant(t, s, "kunde", "kunde.de")
+	s.store.CreateNode(ctx, store.Node{ID: "n1", TenantID: "kunde", Hostname: "h", PublicKey: "k", IPAddress: "1.2.3.4"})
+	until := time.Now().Add(time.Hour).UTC().Truncate(time.Second)
+	s.store.SetNodeMaintenance(ctx, "n1", store.Maintenance{Until: until, Reason: "intern", PublicReason: "öffentlich"})
+	nc, err := (&directory{store: s.store}).NodeContext(ctx, "n1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if nc.Maintenance == nil || !nc.Maintenance.Until.Equal(until) || nc.Maintenance.PublicReason != "öffentlich" {
+		t.Errorf("Maintenance: %+v", nc.Maintenance)
+	}
+}
+
+func TestLease_IssuedOnConnectAndSigned(t *testing.T) {
+	s, _ := startServer(t)
+	createTenant(t, s, "kunde", "kunde.de")
+	agent := newAgent(t, s, issueToken(t, s, "kunde"))
+	agent.enroll(t, "n1")
+	_, events := agent.connectEvents(t)
+
+	ev := nextEvent(t, events, stream.EventLeaseRenew)
+	if err := stream.VerifyEvent(ev, s.MasterPublicKey()); err != nil {
+		t.Fatalf("Event nicht vom Server signiert: %v", err)
+	}
+	l, err := license.ParseLease(ev.Payload, s.MasterPublicKey())
+	if err != nil {
+		t.Fatalf("Lease ungültig: %v", err)
+	}
+	if l.NodeID != "n1" || l.TenantID != "kunde" {
+		t.Errorf("Lease: %+v", l)
+	}
+	if d := time.Until(l.ValidUntil); d < 7*24*time.Hour-time.Minute || d > 7*24*time.Hour {
+		t.Errorf("Pro-Lease läuft %v, erwartet 7 Tage", d)
+	}
+	stored, err := s.store.GetLease(ctx, "n1")
+	if err != nil || !stored.ValidUntil.Equal(l.ValidUntil) {
+		t.Errorf("gespeicherte Lease: %+v %v", stored, err)
+	}
+}
+
+func TestLease_Renewal(t *testing.T) {
+	s, _ := startServer(t, func(c *Config) { c.RefreshInterval = 20 * time.Millisecond; c.LeaseDuration = 300 * time.Millisecond })
+	createTenant(t, s, "kunde", "kunde.de")
+	agent := newAgent(t, s, issueToken(t, s, "kunde"))
+	agent.enroll(t, "n1")
+	_, events := agent.connectEvents(t)
+
+	first, _ := license.ParseLease(nextEvent(t, events, stream.EventLeaseRenew).Payload, s.MasterPublicKey())
+	second, _ := license.ParseLease(nextEvent(t, events, stream.EventLeaseRenew).Payload, s.MasterPublicKey())
+	if !second.ValidUntil.After(first.ValidUntil) {
+		t.Errorf("nicht verlängert: %v → %v", first.ValidUntil, second.ValidUntil)
+	}
+}
+
+// Ungeplantes Trennen: Wartungsseite bis zum Ablauf der Lease, danach weg.
+func TestDisconnect_RoutesUntilLeaseExpiry(t *testing.T) {
+	s, _ := startServer(t, func(c *Config) { c.RefreshInterval = 20 * time.Millisecond; c.LeaseDuration = 600 * time.Millisecond })
+	_, stop := connectedAgent(t, s, "n1")
+	stop()
+	eventually(t, "Wartungsseite", func() bool { return strings.Contains(providerConfig(t, s), policy.InterceptorService) })
+	eventually(t, "Routen nach Lease-Ablauf entfernt", func() bool { return providerConfig(t, s) == "{}" })
+}
+
+// drain entfernt die Routen eines getrennten Knotens sofort – trotz gültiger Lease.
+func TestDisconnect_DrainRemovesImmediately(t *testing.T) {
+	s, _ := startServer(t, func(c *Config) { c.RefreshInterval = 20 * time.Millisecond })
+	_, stop := connectedAgent(t, s, "n1")
+	stop()
+	eventually(t, "Wartungsseite", func() bool { return strings.Contains(providerConfig(t, s), policy.InterceptorService) })
+	if err := s.store.SetNodeStatus(ctx, "n1", store.NodeDrained); err != nil {
+		t.Fatal(err)
+	}
+	eventually(t, "drain entfernt Routen", func() bool { return providerConfig(t, s) == "{}" })
+}
+
+// Befehle aus der Warteschlange (die CLI ist ein eigener Prozess) werden
+// zugestellt – auch solche, die vor dem Verbinden eingereiht wurden.
+func TestNodeCommands_Delivered(t *testing.T) {
+	s, _ := startServer(t, func(c *Config) { c.RefreshInterval = 20 * time.Millisecond })
+	createTenant(t, s, "kunde", "kunde.de")
+	agent := newAgent(t, s, issueToken(t, s, "kunde"))
+	agent.enroll(t, "n1")
+	s.store.EnqueueNodeCommand(ctx, "n1", stream.CmdResync, "")
+
+	_, events := agent.connectEvents(t)
+	ev := nextEvent(t, events, stream.EventNodeCommand)
+	if err := stream.VerifyEvent(ev, s.MasterPublicKey()); err != nil {
+		t.Fatalf("Befehl nicht signiert: %v", err)
+	}
+	if cmd, err := stream.ParseNodeCommand(ev); err != nil || cmd.Command != stream.CmdResync {
+		t.Errorf("Befehl: %+v %v", cmd, err)
+	}
+
+	s.store.EnqueueNodeCommand(ctx, "n1", stream.CmdDrain, "Umzug")
+	ev = nextEvent(t, events, stream.EventNodeCommand)
+	if cmd, _ := stream.ParseNodeCommand(ev); cmd.Command != stream.CmdDrain || cmd.Reason != "Umzug" {
+		t.Errorf("zweiter Befehl: %+v", cmd)
+	}
+	eventually(t, "als gesendet markiert", func() bool {
+		cmds, _ := s.store.PendingNodeCommands(ctx, "n1")
+		return len(cmds) == 0
+	})
+}
+
+func TestRotateKey(t *testing.T) {
+	s, _ := startServer(t)
+	agent, _ := connectedAgent(t, s, "n1")
+	other, _ := connectedAgent(t, s, "n2")
+	newKey, _ := auth.GenerateKey()
+	newPub := auth.EncodePublicKey(newKey.Public().(ed25519.PublicKey))
+	req := RotateKeyRequest{PublicKey: newPub, Proof: auth.RotationProof("n1", newKey)}
+
+	if r := agent.do(t, http.MethodPost, "/api/v1/rotate-key", RotateKeyRequest{PublicKey: newPub, Proof: "AAAA"}); r.StatusCode != http.StatusBadRequest {
+		t.Errorf("falscher Besitznachweis: %d", r.StatusCode)
+	}
+	if r := agent.do(t, http.MethodPost, "/api/v1/rotate-key", req); r.StatusCode != http.StatusNoContent {
+		t.Fatalf("Rotation: %d", r.StatusCode)
+	}
+	if n, _ := s.store.GetNode(ctx, "n1"); n.PublicKey != newPub {
+		t.Error("Schlüssel nicht getauscht")
+	}
+	if r := agent.do(t, http.MethodPost, "/api/v1/rotate-key", req); r.StatusCode != http.StatusUnauthorized {
+		t.Errorf("alter Schlüssel noch gültig: %d", r.StatusCode)
+	}
+	oldSigner := agent.signer
+	agent.signer = &auth.Signer{Key: newKey}
+	if r := agent.do(t, http.MethodPost, "/api/v1/rotate-key", req); r.StatusCode != http.StatusNoContent {
+		t.Errorf("Wiederholung mit neuem Schlüssel (Wiederaufnahme nach Absturz): %d", r.StatusCode)
+	}
+	agent.signer = oldSigner
+
+	// Der Besitznachweis ist an die Knoten-ID gebunden: Ein Nachweis für n2
+	// gilt nicht für n1.
+	_ = other
+	another, _ := auth.GenerateKey()
+	anotherPub := auth.EncodePublicKey(another.Public().(ed25519.PublicKey))
+	agent.signer = &auth.Signer{Key: newKey}
+	foreign := RotateKeyRequest{PublicKey: anotherPub, Proof: auth.RotationProof("n2", another)}
+	if r := agent.do(t, http.MethodPost, "/api/v1/rotate-key", foreign); r.StatusCode != http.StatusBadRequest {
+		t.Errorf("Nachweis für anderen Knoten: %d", r.StatusCode)
+	}
+}
+
+func TestDirectory_FeaturesPaymentDisconnected(t *testing.T) {
+	s, _ := startServer(t)
+	if _, err := s.store.CreateTenant(ctx, store.Tenant{
+		ID: "kunde", Name: "k", Email: "k@x.de", Tier: store.TierPro, MaxRoutes: 5,
+		AllowedDomains: []string{"kunde.de"}, ValidUntil: time.Now().AddDate(1, 0, 0),
+		Features: []string{"custom_middleware"},
+	}); err != nil {
+		t.Fatal(err)
+	}
+	s.store.CreateNode(ctx, store.Node{ID: "n1", TenantID: "kunde", Hostname: "h", PublicKey: "k", IPAddress: "1.2.3.4", Status: store.NodeOffline})
+	s.store.SetTenantPayment(ctx, "kunde", time.Now().Add(-10*24*time.Hour))
+
+	nc, err := (&directory{store: s.store}).NodeContext(ctx, "n1")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !nc.License.HasFeature(license.FeatureCustomMiddleware) {
+		t.Error("Features nicht in der Lizenz")
+	}
+	if nc.Tenant.DunningLevel != 1 {
+		t.Errorf("Mahnstufe %d, erwartet 1 (10 Tage überfällig)", nc.Tenant.DunningLevel)
+	}
+	if !nc.Disconnected {
+		t.Error("getrennter Knoten nicht erkannt")
+	}
+}
+
+// recorder ist ein Benachrichtigungsziel für Tests; failFirst lässt die
+// ersten n Zustellungen scheitern.
+type recorder struct {
+	mu        sync.Mutex
+	msgs      []notify.Message
+	failFirst int
+}
+
+func (r *recorder) Send(_ context.Context, m notify.Message) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if r.failFirst > 0 {
+		r.failFirst--
+		return errors.New("Ziel nicht erreichbar")
+	}
+	r.msgs = append(r.msgs, m)
+	return nil
+}
+
+func (r *recorder) matching(substr string) []notify.Message {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	var out []notify.Message
+	for _, m := range r.msgs {
+		if strings.Contains(m.Title+" "+m.Body, substr) {
+			out = append(out, m)
+		}
+	}
+	return out
+}
+
+func fastJobs(rec *recorder) func(*Config) {
+	return func(c *Config) {
+		c.RefreshInterval = 20 * time.Millisecond
+		c.Notify = rec
+	}
+}
+
+func commercialTenant(t *testing.T, s *Server, id string, validFor time.Duration) {
+	t.Helper()
+	if _, err := s.store.CreateTenant(ctx, store.Tenant{
+		ID: id, Name: id, Email: id + "@example.com", Tier: store.TierPro, MaxRoutes: 10,
+		AllowedDomains: []string{"kunde.de"}, ValidUntil: time.Now().Add(validFor),
+	}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestCheckmkEndpoint(t *testing.T) {
+	s, _ := startServer(t)
+	commercialTenant(t, s, "kunde", 20*24*time.Hour)
+	connectedAgent(t, s, "n1")
+
+	resp, err := http.Get("http://" + s.ProviderAddr() + "/metrics/checkmk")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	body, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode != 200 || !strings.HasPrefix(resp.Header.Get("Content-Type"), "text/plain") {
+		t.Fatalf("Status %d, Content-Type %q", resp.StatusCode, resp.Header.Get("Content-Type"))
+	}
+	out := string(body)
+	for _, want := range []string{`1 "Sultan_Tenant_kunde" days_left=19;30;14`, `0 "Sultan_Payment_kunde"`, `0 "Sultan_Node_n1"`, `0 "Sultan_Policy_Violations"`} {
+		if !strings.Contains(out, want) {
+			t.Errorf("fehlt %q in:\n%s", want, out)
+		}
+	}
+}
+
+func TestJob_ExpiresCommercialTenantOnly(t *testing.T) {
+	rec := &recorder{}
+	s, _ := startServer(t, fastJobs(rec))
+	commercialTenant(t, s, "kunde", 150*time.Millisecond)
+	if _, err := s.store.CreateTenant(ctx, store.Tenant{
+		ID: "homelab", Name: "h", Email: "h@x.de", Tier: store.TierCommunity, MaxRoutes: 5,
+		AllowedDomains: []string{"x.de"}, ValidUntil: time.Now().Add(150 * time.Millisecond),
+	}); err != nil {
+		t.Fatal(err)
+	}
+	eventually(t, "kommerzieller Vertrag auf expired", func() bool {
+		tn, _ := s.store.GetTenant(ctx, "kunde")
+		return tn.Status == store.TenantExpired
+	})
+	time.Sleep(100 * time.Millisecond)
+	if tn, _ := s.store.GetTenant(ctx, "homelab"); tn.Status != store.TenantActive {
+		t.Errorf("Community abgelaufen: %s", tn.Status)
+	}
+	eventually(t, "Benachrichtigung Vertragsende", func() bool { return len(rec.matching("abgelaufen")) == 1 })
+	if m := rec.matching("abgelaufen")[0]; m.Severity != notify.Critical || !strings.Contains(m.Title, "kunde") {
+		t.Errorf("Nachricht: %+v", m)
+	}
+}
+
+func TestNotifications_ContractOnce(t *testing.T) {
+	rec := &recorder{}
+	s, _ := startServer(t, fastJobs(rec))
+	commercialTenant(t, s, "kunde", 10*24*time.Hour) // innerhalb der 14-Tage-Schwelle
+	eventually(t, "Benachrichtigung", func() bool { return len(rec.matching("kunde")) > 0 })
+	time.Sleep(150 * time.Millisecond) // mehrere Job-Runden
+	if got := rec.matching("kunde"); len(got) != 1 || got[0].Severity != notify.Critical {
+		t.Errorf("erwartet genau eine kritische Nachricht, bekommen %+v", got)
+	}
+}
+
+func TestNotifications_Dunning(t *testing.T) {
+	rec := &recorder{}
+	s, _ := startServer(t, fastJobs(rec))
+	commercialTenant(t, s, "kunde", 365*24*time.Hour)
+	s.store.SetTenantPayment(ctx, "kunde", time.Now().Add(-9*24*time.Hour))
+	eventually(t, "Mahnstufe 1", func() bool { return len(rec.matching("Mahnstufe 1")) == 1 })
+	if m := rec.matching("Mahnstufe 1")[0]; m.Severity != notify.Warning {
+		t.Errorf("Schweregrad: %v", m.Severity)
+	}
+}
+
+func TestNotifications_NodeOffline(t *testing.T) {
+	rec := &recorder{}
+	s, _ := startServer(t, fastJobs(rec), func(c *Config) { c.OfflineAlertAfter = 100 * time.Millisecond })
+	_, stop := connectedAgent(t, s, "n1")
+	_, stop2 := connectedAgent(t, s, "n2")
+	agent2, _ := connectedAgent(t, s, "n3")
+	agent2.do(t, http.MethodPost, "/api/v1/maintenance", MaintenanceRequest{Enabled: true})
+	_ = stop2
+	stop()
+	eventually(t, "Offline-Alarm", func() bool { return len(rec.matching("n1")) == 1 })
+	time.Sleep(150 * time.Millisecond)
+	if got := rec.matching("n1"); len(got) != 1 || got[0].Severity != notify.Critical {
+		t.Errorf("erwartet genau einen Alarm: %+v", got)
+	}
+	if len(rec.matching("n2")) != 0 || len(rec.matching("n3")) != 0 {
+		t.Error("Alarm für verbundenen Knoten")
+	}
+}
+
+func TestNotifications_NoAlarmDuringMaintenance(t *testing.T) {
+	rec := &recorder{}
+	s, _ := startServer(t, fastJobs(rec), func(c *Config) { c.OfflineAlertAfter = 50 * time.Millisecond })
+	agent, stop := connectedAgent(t, s, "n1")
+	agent.do(t, http.MethodPost, "/api/v1/maintenance", MaintenanceRequest{Enabled: true, Duration: "1h"})
+	stop()
+	time.Sleep(300 * time.Millisecond)
+	if got := rec.matching("n1"); len(got) != 0 {
+		t.Errorf("Alarm trotz angemeldeter Wartung: %+v", got)
+	}
+}
+
+func TestNotifications_Violation(t *testing.T) {
+	rec := &recorder{}
+	s, _ := startServer(t, fastJobs(rec))
+	agent, _ := connectedAgent(t, s, "n1")
+	agent.do(t, http.MethodPost, "/api/v1/state", wpState("bank.de"))
+	eventually(t, "Verstoß gemeldet", func() bool { return len(rec.matching("bank.de")) == 1 })
+	if m := rec.matching("bank.de")[0]; m.Severity != notify.Warning || !strings.Contains(m.Body, "n1") {
+		t.Errorf("Nachricht: %+v", m)
+	}
+}
+
+// Scheitert die Zustellung, wird es beim nächsten Durchlauf erneut versucht.
+func TestNotifications_RetryOnFailure(t *testing.T) {
+	rec := &recorder{failFirst: 2}
+	s, _ := startServer(t, fastJobs(rec))
+	commercialTenant(t, s, "kunde", 10*24*time.Hour)
+	eventually(t, "Zustellung nach Wiederholung", func() bool { return len(rec.matching("kunde")) == 1 })
+	time.Sleep(100 * time.Millisecond)
+	if n := len(rec.matching("kunde")); n != 1 {
+		t.Errorf("%d Nachrichten, erwartet 1", n)
+	}
+}
+
+// Massenhaftes Durchprobieren von Einladungen wird gebremst – vor der
+// Signaturprüfung, pro Client-IP.
+func TestEnroll_RateLimited(t *testing.T) {
+	s, _ := startServer(t, func(c *Config) { c.EnrollLimit = 3 })
+	createTenant(t, s, "kunde", "kunde.de")
+	agent := newAgent(t, s, issueToken(t, s, "kunde"))
+	agent.secret = crypto.TokenPrefix + strings.Repeat("A", 43) // falsch geraten
+	for i := range 3 {
+		if r := agent.enroll(t, "n1"); r.StatusCode != http.StatusForbidden {
+			t.Fatalf("Versuch %d: %d", i+1, r.StatusCode)
+		}
+	}
+	r := agent.enroll(t, "n1")
+	if r.StatusCode != http.StatusTooManyRequests || r.Header.Get("Retry-After") == "" {
+		t.Errorf("4. Versuch: %d, Retry-After %q", r.StatusCode, r.Header.Get("Retry-After"))
+	}
+	// Auch unsignierte Fluten zählen.
+	req, _ := http.NewRequest(http.MethodPost, agent.base+"/api/v1/enroll", strings.NewReader(`{}`))
+	if resp, err := agent.hc.Do(req); err != nil || resp.StatusCode != http.StatusTooManyRequests {
+		t.Errorf("unsigniert: %v %v", resp, err)
+	}
+}
+
+func TestConfigDefaults_EnrollLimit(t *testing.T) {
+	if c := (Config{}).withDefaults(); c.EnrollLimit != 10 {
+		t.Errorf("EnrollLimit-Default %d, erwartet 10 pro Minute", c.EnrollLimit)
+	}
+}
+
+// „Wieder online“ nur nach einem Offline-Alarm und genau einmal pro Ausfall.
+func TestNotifications_BackOnline(t *testing.T) {
+	rec := &recorder{}
+	s, _ := startServer(t, fastJobs(rec), func(c *Config) { c.OfflineAlertAfter = 100 * time.Millisecond })
+	agent, stop := connectedAgent(t, s, "n1")
+	stop()
+	eventually(t, "Offline-Alarm", func() bool { return len(rec.matching("offline")) == 1 })
+
+	agent.connect(t)
+	eventually(t, "wieder online", func() bool { return len(rec.matching("wieder online")) == 1 })
+	m := rec.matching("wieder online")[0]
+	if m.Severity != notify.Info || !strings.Contains(m.Body, "n1") {
+		t.Errorf("Nachricht: %+v", m)
+	}
+	time.Sleep(150 * time.Millisecond)
+	if n := len(rec.matching("wieder online")); n != 1 {
+		t.Errorf("%d Wieder-online-Nachrichten, erwartet 1", n)
+	}
+}
+
+func TestNotifications_NoBackOnlineWithoutAlarm(t *testing.T) {
+	rec := &recorder{}
+	s, _ := startServer(t, fastJobs(rec), func(c *Config) { c.OfflineAlertAfter = time.Hour })
+	agent, stop := connectedAgent(t, s, "n1")
+	stop()
+	eventually(t, "offline", func() bool { n, _ := s.store.GetNode(ctx, "n1"); return n.Status == store.NodeOffline })
+	agent.connect(t)
+	eventually(t, "online", func() bool { return s.hub.Connected("n1") })
+	time.Sleep(150 * time.Millisecond)
+	if got := rec.matching("wieder online"); len(got) != 0 {
+		t.Errorf("Meldung ohne vorherigen Alarm: %+v", got)
+	}
+}
+
+func TestConfigDefaults_EnrollLimitDisabled(t *testing.T) {
+	if c := (Config{EnrollLimit: -1}).withDefaults(); c.EnrollLimit != -1 {
+		t.Errorf("-1 (unbegrenzt) überschrieben: %d", c.EnrollLimit)
+	}
+}