software steht so weit.

jetzt build + docker build und testen

pkg/server/leases.go

@@ -0,0 +1,92 @@
+package server
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"time"
+
+	"sultan/pkg/license"
+	"sultan/pkg/store"
+	"sultan/pkg/stream"
+)
+
+// ensureLease stellt die Lease eines verbundenen Knotens aus bzw. erneuert
+// sie ab renew_after und schickt sie per lease_renew. Mit always wird auch
+// eine noch gültige Lease erneut zugestellt (beim Verbinden).
+func (s *Server) ensureLease(nodeID string, always bool) {
+	ctx := context.Background()
+	now := time.Now()
+	current, err := s.store.GetLease(ctx, nodeID)
+	if err == nil && now.Before(current.RenewAfter) {
+		if always {
+			s.sendLease(nodeID, []byte(current.Document))
+		}
+		return
+	}
+	if err != nil && !errors.Is(err, store.ErrNotFound) {
+		s.log.Error("Lease lesen", "node", nodeID, "err", err)
+		return
+	}
+	node, err := s.store.GetNode(ctx, nodeID)
+	if err != nil {
+		return
+	}
+	tenant, err := s.store.GetTenant(ctx, node.TenantID)
+	if err != nil || tenant.Status == store.TenantQuarantined {
+		return
+	}
+	lic := licenseOf(tenant)
+	terms, ok := license.TermsFor(lic.Tier, node.Maintenance.Active(now), lic.ValidUntil, now, s.cfg.LeaseDuration, nil)
+	if !ok {
+		s.log.Warn("Keine Lease: Vertrag abgelaufen", "node", nodeID, "tenant", tenant.ID)
+		return
+	}
+	lease, err := (&license.Issuer{Key: s.master}).IssueLease(lic, nodeID, terms, now)
+	if err != nil {
+		s.log.Error("Lease ausstellen", "node", nodeID, "err", err)
+		return
+	}
+	doc, _ := json.Marshal(lease)
+	if err := s.store.PutLease(ctx, store.Lease{
+		NodeID: nodeID, IssuedAt: lease.IssuedAt, RenewAfter: lease.RenewAfter, ValidUntil: lease.ValidUntil, Document: string(doc),
+	}); err != nil {
+		s.log.Error("Lease speichern", "node", nodeID, "err", err)
+		return
+	}
+	s.log.Info("Lease ausgestellt", "node", nodeID, "valid_until", terms.ValidUntil, "renew_after", terms.RenewAfter)
+	s.sendLease(nodeID, doc)
+}
+
+func (s *Server) sendLease(nodeID string, doc []byte) {
+	if err := s.hub.Send(nodeID, stream.Event{Type: stream.EventLeaseRenew, Payload: doc}); err != nil {
+		s.log.Debug("Lease nicht zugestellt", "node", nodeID, "err", err)
+	}
+}
+
+// leaseValid meldet, ob der Knoten eine noch gültige Lease hat.
+func (s *Server) leaseValid(nodeID string) bool {
+	l, err := s.store.GetLease(context.Background(), nodeID)
+	return err == nil && time.Now().Before(l.ValidUntil)
+}
+
+// dispatchCommands stellt Befehle aus der Warteschlange zu.
+func (s *Server) dispatchCommands(nodeID string) {
+	ctx := context.Background()
+	cmds, err := s.store.PendingNodeCommands(ctx, nodeID)
+	if err != nil {
+		s.log.Error("Befehle lesen", "node", nodeID, "err", err)
+		return
+	}
+	for _, c := range cmds {
+		payload, _ := json.Marshal(stream.NodeCommand{Command: c.Command, Reason: c.Reason})
+		if err := s.hub.Send(nodeID, stream.Event{Type: stream.EventNodeCommand, Payload: payload}); err != nil {
+			return // später erneut (nächster Refresh oder nächste Verbindung)
+		}
+		if err := s.store.MarkNodeCommandSent(ctx, c.ID); err != nil {
+			s.log.Error("Befehl als gesendet markieren", "node", nodeID, "err", err)
+			return
+		}
+		s.log.Info("Befehl zugestellt", "node", nodeID, "command", c.Command, "reason", c.Reason)
+	}
+}