feat: establish NekoNest Cloud control and relay

relay/internal/purge/manager.go

@@ -0,0 +1,120 @@
+package purge
+
+import (
+	"context"
+	"errors"
+	"log/slog"
+	"sync"
+
+	"github.com/klarkxy/nekonest-cloud/relay/internal/controlplane"
+	"github.com/klarkxy/nekonest-cloud/relay/internal/tenantpurge"
+)
+
+type Registry interface {
+	QuiesceForPurge(tenantID string, generation int64) error
+}
+
+type ControlPlane interface {
+	AdvancePurge(context.Context, controlplane.PurgeAdvance) error
+}
+
+type Config struct {
+	DataRoot      string
+	BackupRoot    string
+	Registry      Registry
+	ControlPlane  ControlPlane
+	MaxConcurrent int
+	Logger        *slog.Logger
+}
+
+type Manager struct {
+	config    Config
+	mu        sync.Mutex
+	inFlight  map[string]struct{}
+	semaphore chan struct{}
+	wait      sync.WaitGroup
+}
+
+func New(config Config) (*Manager, error) {
+	if config.DataRoot == "" || config.BackupRoot == "" || config.Registry == nil || config.ControlPlane == nil {
+		return nil, errors.New("purge manager requires data, backup, registry, and control-plane ports")
+	}
+	if config.MaxConcurrent <= 0 {
+		config.MaxConcurrent = 1
+	}
+	if config.MaxConcurrent > 4 {
+		return nil, errors.New("purge concurrency is unreasonably high")
+	}
+	if config.Logger == nil {
+		config.Logger = slog.Default()
+	}
+	return &Manager{
+		config: config, inFlight: make(map[string]struct{}),
+		semaphore: make(chan struct{}, config.MaxConcurrent),
+	}, nil
+}
+
+func (manager *Manager) Handle(ctx context.Context, assignments []controlplane.PurgeAssignment) {
+	for _, assignment := range assignments {
+		manager.mu.Lock()
+		if _, exists := manager.inFlight[assignment.PurgeID]; exists {
+			manager.mu.Unlock()
+			continue
+		}
+		select {
+		case manager.semaphore <- struct{}{}:
+			manager.inFlight[assignment.PurgeID] = struct{}{}
+			manager.wait.Add(1)
+			manager.mu.Unlock()
+			go func(assignment controlplane.PurgeAssignment) {
+				defer func() {
+					<-manager.semaphore
+					manager.mu.Lock()
+					delete(manager.inFlight, assignment.PurgeID)
+					manager.mu.Unlock()
+					manager.wait.Done()
+				}()
+				if err := manager.process(ctx, assignment); err != nil && ctx.Err() == nil {
+					manager.config.Logger.Error("Relay tenant purge failed",
+						"purge_id", assignment.PurgeID, "tenant_id", assignment.TenantID, "error", err)
+				}
+			}(assignment)
+		default:
+			manager.mu.Unlock()
+		}
+	}
+}
+
+func (manager *Manager) process(ctx context.Context, assignment controlplane.PurgeAssignment) error {
+	if assignment.PurgeID == "" || assignment.TenantID == "" || assignment.PlacementGeneration < 1 {
+		return errors.New("purge assignment is incomplete")
+	}
+	if err := manager.config.Registry.QuiesceForPurge(
+		assignment.TenantID, assignment.PlacementGeneration,
+	); err != nil {
+		return manager.fail(ctx, assignment, "relay_purge_quiesce_failed", err)
+	}
+	result, err := tenantpurge.Purge(
+		ctx, manager.config.DataRoot, manager.config.BackupRoot,
+		assignment.TenantID, assignment.PlacementGeneration,
+	)
+	if err != nil {
+		return manager.fail(ctx, assignment, "relay_purge_delete_failed", err)
+	}
+	return manager.config.ControlPlane.AdvancePurge(ctx, controlplane.PurgeAdvance{
+		PurgeID: assignment.PurgeID, Action: "completed", EvidenceSHA256: result.EvidenceSHA256,
+	})
+}
+
+func (manager *Manager) fail(
+	ctx context.Context, assignment controlplane.PurgeAssignment, code string, cause error,
+) error {
+	if err := manager.config.ControlPlane.AdvancePurge(ctx, controlplane.PurgeAdvance{
+		PurgeID: assignment.PurgeID, Action: "failed", ErrorCode: code,
+	}); err != nil {
+		return errors.Join(cause, err)
+	}
+	return cause
+}
+
+func (manager *Manager) Wait() { manager.wait.Wait() }