snapshot of https://github.com/seaweedfs/seaweedfs.git (master, 2026-09-16; blobs > 131072B omitted)

weed/admin/maintenance/maintenance_policy_wiring_test.go

@@ -0,0 +1,209 @@
+package maintenance
+
+import (
+	"testing"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/worker_pb"
+	"github.com/seaweedfs/seaweedfs/weed/worker/tasks"
+	"github.com/seaweedfs/seaweedfs/weed/worker/types"
+)
+
+// The detectors and schedulers live in a process-global registry, so these tests restore
+// whatever they change. Otherwise a test that disables a task leaks that state into every
+// later test in the package.
+func snapshotDetectorState(t *testing.T) {
+	t.Helper()
+
+	registry := tasks.GetGlobalTypesRegistry()
+	enabled := make(map[types.TaskType]bool)
+	maxConcurrent := make(map[types.TaskType]int)
+	for taskType, detector := range registry.GetAllDetectors() {
+		enabled[taskType] = detector.IsEnabled()
+	}
+	for taskType, scheduler := range registry.GetAllSchedulers() {
+		maxConcurrent[taskType] = scheduler.GetMaxConcurrent()
+	}
+
+	t.Cleanup(func() {
+		for taskType, detector := range registry.GetAllDetectors() {
+			if setter, ok := detector.(interface{ SetEnabled(bool) }); ok {
+				setter.SetEnabled(enabled[taskType])
+			}
+		}
+		for taskType, scheduler := range registry.GetAllSchedulers() {
+			if setter, ok := scheduler.(interface{ SetMaxConcurrent(int) }); ok {
+				setter.SetMaxConcurrent(maxConcurrent[taskType])
+			}
+		}
+	})
+}
+
+// TestPolicyReachesRegisteredDetectors is the regression test for the half of the scan-flood bug
+// that a corrected policy alone did not fix: MaintenanceIntegration pushes the policy into
+// detectors and schedulers through interface{ SetEnabled(bool) } and
+// interface{ SetMaxConcurrent(int) } type assertions, but every task is backed by
+// base.GenericDetector/base.GenericScheduler, which implemented neither. The assertions
+// failed silently for every task on every startup, so the policy never reached
+// detector.IsEnabled() - which is what ScanWithTaskDetectors gates scanning on.
+func TestPolicyReachesRegisteredDetectors(t *testing.T) {
+	snapshotDetectorState(t)
+
+	registry := tasks.GetGlobalTypesRegistry()
+	if len(registry.GetAllDetectors()) == 0 {
+		t.Fatal("no detectors registered, the test cannot prove anything")
+	}
+
+	// Enable everything first so the disabling below cannot pass by accident.
+	policy := policyWithAllTasks(t, true)
+	NewMaintenanceIntegration(NewMaintenanceQueue(policy), policy)
+
+	for taskType, detector := range registry.GetAllDetectors() {
+		if !detector.IsEnabled() {
+			t.Fatalf("detector %s is disabled after an all-enabled policy was applied", taskType)
+		}
+	}
+
+	// Now disable everything through the policy and check it lands on the detectors.
+	policy = policyWithAllTasks(t, false)
+	NewMaintenanceIntegration(NewMaintenanceQueue(policy), policy)
+
+	for taskType, detector := range registry.GetAllDetectors() {
+		if detector.IsEnabled() {
+			t.Errorf("detector %s still reports enabled after the policy disabled it; "+
+				"the policy is not reaching the flag ScanWithTaskDetectors gates on", taskType)
+		}
+	}
+	for taskType, scheduler := range registry.GetAllSchedulers() {
+		if scheduler.IsEnabled() {
+			t.Errorf("scheduler %s still reports enabled after the policy disabled it", taskType)
+		}
+	}
+}
+
+// TestPolicyMaxConcurrentReachesSchedulers covers the SetMaxConcurrent half of the same
+// wiring. GetMaxConcurrent is what MaintenanceQueue.getMaxConcurrentForTaskType asks before
+// starting another task of a type.
+func TestPolicyMaxConcurrentReachesSchedulers(t *testing.T) {
+	snapshotDetectorState(t)
+
+	const wantMaxConcurrent = 7
+
+	policy := policyWithAllTasks(t, true)
+	for _, taskPolicy := range policy.TaskPolicies {
+		taskPolicy.MaxConcurrent = wantMaxConcurrent
+	}
+	NewMaintenanceIntegration(NewMaintenanceQueue(policy), policy)
+
+	registry := tasks.GetGlobalTypesRegistry()
+	for taskType, scheduler := range registry.GetAllSchedulers() {
+		if _, covered := policy.TaskPolicies[string(taskType)]; !covered {
+			continue
+		}
+		if got := scheduler.GetMaxConcurrent(); got != wantMaxConcurrent {
+			t.Errorf("scheduler %s max concurrent = %d, want %d from the policy", taskType, got, wantMaxConcurrent)
+		}
+	}
+}
+
+// TestPolicyWithoutEntryLeavesTaskAlone guards the direction that would have been a silent
+// outage: IsTaskEnabled reports false for a task type the policy does not list, so applying
+// it unconditionally would disable every task the policy has no entry for.
+func TestPolicyWithoutEntryLeavesTaskAlone(t *testing.T) {
+	snapshotDetectorState(t)
+
+	registry := tasks.GetGlobalTypesRegistry()
+
+	// Start from a policy that enables everything.
+	enabling := policyWithAllTasks(t, true)
+	NewMaintenanceIntegration(NewMaintenanceQueue(enabling), enabling)
+
+	// An empty policy has an entry for nothing at all.
+	empty := &MaintenancePolicy{TaskPolicies: make(map[string]*worker_pb.TaskPolicy)}
+	NewMaintenanceIntegration(NewMaintenanceQueue(empty), empty)
+
+	for taskType, detector := range registry.GetAllDetectors() {
+		if !detector.IsEnabled() {
+			t.Errorf("detector %s was disabled by a policy that has no entry for it; "+
+				"a missing entry means no opinion, not disabled", taskType)
+		}
+	}
+}
+
+// TestBuildPolicyCoversEveryRegisteredTask keeps BuildPolicyFromTaskConfigs and the task
+// registry in step. A registered task with no policy entry has no enabled flag and no
+// concurrency limit of its own, which is the state ec_balance was in.
+func TestBuildPolicyCoversEveryRegisteredTask(t *testing.T) {
+	policy := BuildPolicyFromTaskConfigs(nil)
+
+	for taskType := range tasks.GetGlobalTypesRegistry().GetAllDetectors() {
+		if _, ok := policy.TaskPolicies[string(taskType)]; !ok {
+			t.Errorf("task %s is registered as a detector but BuildPolicyFromTaskConfigs "+
+				"builds no policy entry for it, so IsTaskEnabled reports false for it", taskType)
+		}
+	}
+}
+
+// TestBuildPolicyIncludesEcBalance pins the specific gap above.
+func TestBuildPolicyIncludesEcBalance(t *testing.T) {
+	policy := BuildPolicyFromTaskConfigs(nil)
+
+	ecBalance := policy.TaskPolicies[string(types.TaskTypeECBalance)]
+	if ecBalance == nil {
+		t.Fatal("no ec_balance entry in the built maintenance policy")
+	}
+	if !IsTaskEnabled(policy, MaintenanceTaskType(types.TaskTypeECBalance)) {
+		t.Error("ec_balance reports disabled with no persisted config, want the compiled-in default of enabled")
+	}
+	if ecBalance.GetEcBalanceConfig() == nil {
+		t.Error("ec_balance policy entry carries no EcBalanceConfig")
+	}
+}
+
+// policyWithAllTasks builds a policy that has an entry for every registered task type,
+// all sharing the same enabled flag.
+func policyWithAllTasks(t *testing.T, enabled bool) *MaintenancePolicy {
+	t.Helper()
+
+	policy := &MaintenancePolicy{
+		GlobalMaxConcurrent: 4,
+		TaskPolicies:        make(map[string]*worker_pb.TaskPolicy),
+	}
+	for taskType := range tasks.GetGlobalTypesRegistry().GetAllDetectors() {
+		policy.TaskPolicies[string(taskType)] = &worker_pb.TaskPolicy{
+			Enabled:               enabled,
+			MaxConcurrent:         1,
+			RepeatIntervalSeconds: 3600,
+		}
+	}
+	return policy
+}
+
+// TestPolicyHelpersTolerateNilPolicy pins the nil handling in the exported policy helpers.
+// MaintenanceConfig.Policy is nil until something builds one, and UpdateConfig accepts a
+// config that has none, so these are reachable with a nil policy - GetTaskPolicy used to
+// dereference it and take the admin process down.
+func TestPolicyHelpersTolerateNilPolicy(t *testing.T) {
+	const taskType = MaintenanceTaskType("balance")
+
+	if got := GetTaskPolicy(nil, taskType); got != nil {
+		t.Errorf("GetTaskPolicy(nil) = %v, want nil", got)
+	}
+	if IsTaskEnabled(nil, taskType) {
+		t.Error("IsTaskEnabled(nil) = true, want false")
+	}
+	if got := GetMaxConcurrent(nil, taskType); got != 1 {
+		t.Errorf("GetMaxConcurrent(nil) = %d, want the safe default 1", got)
+	}
+	if got := GetRepeatInterval(nil, taskType); got != 0 {
+		t.Errorf("GetRepeatInterval(nil) = %d, want 0 so callers fall back to their own default", got)
+	}
+
+	// A policy that exists but lists nothing must behave the same way.
+	empty := &MaintenancePolicy{}
+	if got := GetTaskPolicy(empty, taskType); got != nil {
+		t.Errorf("GetTaskPolicy(empty) = %v, want nil", got)
+	}
+	if IsTaskEnabled(empty, taskType) {
+		t.Error("IsTaskEnabled(empty) = true, want false")
+	}
+}