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

weed/worker/tasks/base/generic_components.go

@@ -0,0 +1,160 @@
+package base
+
+import (
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/worker/types"
+)
+
+// GenericDetector implements TaskDetector using function-based logic
+type GenericDetector struct {
+	taskDef *TaskDefinition
+}
+
+// NewGenericDetector creates a detector from a task definition
+func NewGenericDetector(taskDef *TaskDefinition) *GenericDetector {
+	return &GenericDetector{taskDef: taskDef}
+}
+
+// GetTaskType returns the task type
+func (d *GenericDetector) GetTaskType() types.TaskType {
+	return d.taskDef.Type
+}
+
+// ScanForTasks scans using the task definition's detection function
+func (d *GenericDetector) ScanForTasks(volumeMetrics []*types.VolumeHealthMetrics, clusterInfo *types.ClusterInfo) ([]*types.TaskDetectionResult, error) {
+	if d.taskDef.DetectionFunc == nil {
+		return nil, nil
+	}
+	return d.taskDef.DetectionFunc(volumeMetrics, clusterInfo, d.taskDef.Config)
+}
+
+// ScanInterval returns the scan interval from task definition
+func (d *GenericDetector) ScanInterval() time.Duration {
+	if d.taskDef.ScanInterval > 0 {
+		return d.taskDef.ScanInterval
+	}
+	return 30 * time.Minute // Default
+}
+
+// IsEnabled returns whether this detector is enabled
+func (d *GenericDetector) IsEnabled() bool {
+	return d.taskDef.Config.IsEnabled()
+}
+
+// SetEnabled turns detection for this task type on or off.
+//
+// The admin maintenance policy is applied to detectors through an
+// interface{ SetEnabled(bool) } type assertion (see
+// MaintenanceIntegration.configureDetectorFromPolicy). Every registered task is
+// backed by this generic detector, so without this method that assertion failed
+// for every task and the policy never reached the flag that
+// ScanWithTaskDetectors actually gates on.
+func (d *GenericDetector) SetEnabled(enabled bool) {
+	d.taskDef.Config.SetEnabled(enabled)
+}
+
+// GenericScheduler implements TaskScheduler using function-based logic
+type GenericScheduler struct {
+	taskDef *TaskDefinition
+}
+
+// NewGenericScheduler creates a scheduler from a task definition
+func NewGenericScheduler(taskDef *TaskDefinition) *GenericScheduler {
+	return &GenericScheduler{taskDef: taskDef}
+}
+
+// GetTaskType returns the task type
+func (s *GenericScheduler) GetTaskType() types.TaskType {
+	return s.taskDef.Type
+}
+
+// CanScheduleNow determines if a task can be scheduled using the task definition's function
+func (s *GenericScheduler) CanScheduleNow(task *types.TaskInput, runningTasks []*types.TaskInput, availableWorkers []*types.WorkerData) bool {
+	if s.taskDef.SchedulingFunc == nil {
+		return s.defaultCanSchedule(task, runningTasks, availableWorkers)
+	}
+	return s.taskDef.SchedulingFunc(task, runningTasks, availableWorkers, s.taskDef.Config)
+}
+
+// defaultCanSchedule provides default scheduling logic
+func (s *GenericScheduler) defaultCanSchedule(task *types.TaskInput, runningTasks []*types.TaskInput, availableWorkers []*types.WorkerData) bool {
+	if !s.taskDef.Config.IsEnabled() {
+		return false
+	}
+
+	// Count running tasks of this type
+	runningCount := 0
+	for _, runningTask := range runningTasks {
+		if runningTask.Type == s.taskDef.Type {
+			runningCount++
+		}
+	}
+
+	// Check concurrency limit
+	maxConcurrent := s.taskDef.MaxConcurrent
+	if maxConcurrent <= 0 {
+		maxConcurrent = 1 // Default
+	}
+	if runningCount >= maxConcurrent {
+		return false
+	}
+
+	// Check if we have available workers
+	for _, worker := range availableWorkers {
+		if worker.CurrentLoad < worker.MaxConcurrent {
+			for _, capability := range worker.Capabilities {
+				if capability == s.taskDef.Type {
+					return true
+				}
+			}
+		}
+	}
+
+	return false
+}
+
+// GetPriority returns the priority for this task
+func (s *GenericScheduler) GetPriority(task *types.TaskInput) types.TaskPriority {
+	return task.Priority
+}
+
+// GetMaxConcurrent returns max concurrent tasks
+func (s *GenericScheduler) GetMaxConcurrent() int {
+	if s.taskDef.MaxConcurrent > 0 {
+		return s.taskDef.MaxConcurrent
+	}
+	return 1 // Default
+}
+
+// GetDefaultRepeatInterval returns the default repeat interval
+func (s *GenericScheduler) GetDefaultRepeatInterval() time.Duration {
+	if s.taskDef.RepeatInterval > 0 {
+		return s.taskDef.RepeatInterval
+	}
+	return 24 * time.Hour // Default
+}
+
+// IsEnabled returns whether this scheduler is enabled
+func (s *GenericScheduler) IsEnabled() bool {
+	return s.taskDef.Config.IsEnabled()
+}
+
+// SetEnabled turns scheduling for this task type on or off. Detector and scheduler
+// share one TaskDefinition, so this is the same flag GenericDetector.SetEnabled sets;
+// both setters exist because the maintenance integration configures the two
+// independently. See GenericDetector.SetEnabled.
+func (s *GenericScheduler) SetEnabled(enabled bool) {
+	s.taskDef.Config.SetEnabled(enabled)
+}
+
+// SetMaxConcurrent applies the policy's concurrency limit for this task type. It is
+// the value GetMaxConcurrent returns, which the maintenance queue uses to decide
+// whether another task of this type may start. Non-positive limits are ignored
+// rather than turning into the implicit default of 1.
+func (s *GenericScheduler) SetMaxConcurrent(maxConcurrent int) {
+	if maxConcurrent <= 0 {
+		return
+	}
+	s.taskDef.MaxConcurrent = maxConcurrent
+}

weed/worker/tasks/base/registration.go

@@ -0,0 +1,151 @@
+package base
+
+import (
+	"fmt"
+
+	"github.com/seaweedfs/seaweedfs/weed/admin/config"
+	"github.com/seaweedfs/seaweedfs/weed/glog"
+	"github.com/seaweedfs/seaweedfs/weed/pb/worker_pb"
+	"github.com/seaweedfs/seaweedfs/weed/worker/tasks"
+	"github.com/seaweedfs/seaweedfs/weed/worker/types"
+)
+
+// GenericFactory creates task instances using a TaskDefinition
+type GenericFactory struct {
+	*tasks.BaseTaskFactory
+	taskDef *TaskDefinition
+}
+
+// NewGenericFactory creates a generic task factory
+func NewGenericFactory(taskDef *TaskDefinition) *GenericFactory {
+	return &GenericFactory{
+		BaseTaskFactory: tasks.NewBaseTaskFactory(
+			taskDef.Type,
+			taskDef.Capabilities,
+			taskDef.Description,
+		),
+		taskDef: taskDef,
+	}
+}
+
+// Create creates a task instance using the task definition
+func (f *GenericFactory) Create(params *worker_pb.TaskParams) (types.Task, error) {
+	if f.taskDef.CreateTask == nil {
+		return nil, fmt.Errorf("no task creation function defined for %s", f.taskDef.Type)
+	}
+	return f.taskDef.CreateTask(params)
+}
+
+// Type returns the task type
+func (f *GenericFactory) Type() string {
+	return string(f.taskDef.Type)
+}
+
+// Description returns a description of what this task does
+func (f *GenericFactory) Description() string {
+	return f.taskDef.Description
+}
+
+// Capabilities returns the task capabilities
+func (f *GenericFactory) Capabilities() []string {
+	return f.taskDef.Capabilities
+}
+
+// GenericSchemaProvider provides config schema from TaskDefinition
+type GenericSchemaProvider struct {
+	taskDef *TaskDefinition
+}
+
+// GetConfigSchema returns the schema from task definition
+func (p *GenericSchemaProvider) GetConfigSchema() *tasks.TaskConfigSchema {
+	return &tasks.TaskConfigSchema{
+		TaskName:    string(p.taskDef.Type),
+		DisplayName: p.taskDef.DisplayName,
+		Description: p.taskDef.Description,
+		Icon:        p.taskDef.Icon,
+		Schema: config.Schema{
+			Fields: p.taskDef.ConfigSpec.Fields,
+		},
+	}
+}
+
+// GenericUIProvider provides UI functionality from TaskDefinition
+type GenericUIProvider struct {
+	taskDef *TaskDefinition
+}
+
+// GetCurrentConfig returns current config as TaskConfig
+func (ui *GenericUIProvider) GetCurrentConfig() types.TaskConfig {
+	return ui.taskDef.Config
+}
+
+// ApplyTaskPolicy applies protobuf TaskPolicy configuration
+func (ui *GenericUIProvider) ApplyTaskPolicy(policy *worker_pb.TaskPolicy) error {
+	return ui.taskDef.Config.FromTaskPolicy(policy)
+}
+
+// ApplyTaskConfig applies TaskConfig interface configuration
+func (ui *GenericUIProvider) ApplyTaskConfig(config types.TaskConfig) error {
+	taskPolicy := config.ToTaskPolicy()
+	return ui.taskDef.Config.FromTaskPolicy(taskPolicy)
+}
+
+// RegisterTask registers a complete task definition with all registries
+func RegisterTask(taskDef *TaskDefinition) {
+	// Validate task definition
+	if err := validateTaskDefinition(taskDef); err != nil {
+		glog.Errorf("Invalid task definition for %s: %v", taskDef.Type, err)
+		return
+	}
+
+	// Create and register factory
+	factory := NewGenericFactory(taskDef)
+	tasks.AutoRegister(taskDef.Type, factory)
+
+	// Create and register detector/scheduler
+	detector := NewGenericDetector(taskDef)
+	scheduler := NewGenericScheduler(taskDef)
+
+	tasks.AutoRegisterTypes(func(registry *types.TaskRegistry) {
+		registry.RegisterTask(detector, scheduler)
+	})
+
+	// Create and register schema provider
+	schemaProvider := &GenericSchemaProvider{taskDef: taskDef}
+	tasks.RegisterTaskConfigSchema(string(taskDef.Type), schemaProvider)
+
+	// Create and register UI provider
+	uiProvider := &GenericUIProvider{taskDef: taskDef}
+	tasks.AutoRegisterUI(func(uiRegistry *types.UIRegistry) {
+		baseUIProvider := tasks.NewBaseUIProvider(
+			taskDef.Type,
+			taskDef.DisplayName,
+			taskDef.Description,
+			taskDef.Icon,
+			schemaProvider.GetConfigSchema,
+			uiProvider.GetCurrentConfig,
+			uiProvider.ApplyTaskPolicy,
+			uiProvider.ApplyTaskConfig,
+		)
+		uiRegistry.RegisterUI(baseUIProvider)
+	})
+
+	glog.V(1).Infof("Registered complete task definition: %s", taskDef.Type)
+}
+
+// validateTaskDefinition ensures the task definition is complete
+func validateTaskDefinition(taskDef *TaskDefinition) error {
+	if taskDef.Type == "" {
+		return fmt.Errorf("task type is required")
+	}
+	if taskDef.Name == "" {
+		return fmt.Errorf("task name is required")
+	}
+	if taskDef.Config == nil {
+		return fmt.Errorf("task config is required")
+	}
+	if taskDef.CreateTask == nil {
+		return fmt.Errorf("task creation function is required")
+	}
+	return nil
+}

weed/worker/tasks/base/task_definition.go

@@ -0,0 +1,105 @@
+package base
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/admin/config"
+	"github.com/seaweedfs/seaweedfs/weed/pb/worker_pb"
+	"github.com/seaweedfs/seaweedfs/weed/worker/types"
+)
+
+// TaskDefinition encapsulates everything needed to define a complete task type
+type TaskDefinition struct {
+	// Basic task information
+	Type         types.TaskType
+	Name         string
+	DisplayName  string
+	Description  string
+	Icon         string
+	Capabilities []string
+
+	// Task configuration
+	Config     TaskConfig
+	ConfigSpec ConfigSpec
+
+	// Task creation
+	CreateTask func(params *worker_pb.TaskParams) (types.Task, error)
+
+	// Detection logic
+	DetectionFunc func(metrics []*types.VolumeHealthMetrics, info *types.ClusterInfo, config TaskConfig) ([]*types.TaskDetectionResult, error)
+	ScanInterval  time.Duration
+
+	// Scheduling logic
+	SchedulingFunc func(task *types.TaskInput, running []*types.TaskInput, workers []*types.WorkerData, config TaskConfig) bool
+	MaxConcurrent  int
+	RepeatInterval time.Duration
+}
+
+// TaskConfig provides a configuration interface that supports type-safe defaults
+type TaskConfig interface {
+	config.ConfigWithDefaults // Extends ConfigWithDefaults for type-safe schema operations
+	IsEnabled() bool
+	SetEnabled(bool)
+	ToTaskPolicy() *worker_pb.TaskPolicy
+	FromTaskPolicy(policy *worker_pb.TaskPolicy) error
+}
+
+// ConfigSpec defines the configuration schema
+type ConfigSpec struct {
+	Fields []*config.Field
+}
+
+// BaseConfig provides common configuration fields with reflection-based serialization
+type BaseConfig struct {
+	Enabled             bool `json:"enabled"`
+	ScanIntervalSeconds int  `json:"scan_interval_seconds"`
+	MaxConcurrent       int  `json:"max_concurrent"`
+}
+
+// IsEnabled returns whether the task is enabled
+func (c *BaseConfig) IsEnabled() bool {
+	return c.Enabled
+}
+
+// SetEnabled sets whether the task is enabled
+func (c *BaseConfig) SetEnabled(enabled bool) {
+	c.Enabled = enabled
+}
+
+// Validate validates the base configuration
+func (c *BaseConfig) Validate() error {
+	// Common validation logic
+	return nil
+}
+
+// ToMap converts config to map using reflection
+// ToTaskPolicy converts BaseConfig to protobuf (partial implementation)
+// Note: Concrete implementations should override this to include task-specific config
+func (c *BaseConfig) ToTaskPolicy() *worker_pb.TaskPolicy {
+	return &worker_pb.TaskPolicy{
+		Enabled:               c.Enabled,
+		MaxConcurrent:         int32(c.MaxConcurrent),
+		RepeatIntervalSeconds: int32(c.ScanIntervalSeconds),
+		CheckIntervalSeconds:  int32(c.ScanIntervalSeconds),
+		// TaskConfig field should be set by concrete implementations
+	}
+}
+
+// FromTaskPolicy loads BaseConfig from protobuf (partial implementation)
+// Note: Concrete implementations should override this to handle task-specific config
+func (c *BaseConfig) FromTaskPolicy(policy *worker_pb.TaskPolicy) error {
+	if policy == nil {
+		return fmt.Errorf("policy is nil")
+	}
+	c.Enabled = policy.Enabled
+	c.MaxConcurrent = int(policy.MaxConcurrent)
+	c.ScanIntervalSeconds = int(policy.RepeatIntervalSeconds)
+	return nil
+}
+
+// ApplySchemaDefaults applies default values from schema using reflection
+func (c *BaseConfig) ApplySchemaDefaults(schema *config.Schema) error {
+	// Use reflection-based approach for BaseConfig since it needs to handle embedded structs
+	return schema.ApplyDefaultsToProtobuf(c)
+}

weed/worker/tasks/base/typed_task.go

@@ -0,0 +1,247 @@
+package base
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/pb/worker_pb"
+	"github.com/seaweedfs/seaweedfs/weed/worker/tasks"
+	"github.com/seaweedfs/seaweedfs/weed/worker/types"
+)
+
+// BaseTypedTask provides a base implementation for typed tasks with logger support
+type BaseTypedTask struct {
+	taskType         types.TaskType
+	taskID           string
+	progress         float64
+	progressCallback func(float64, string)
+	currentStage     string
+	cancelled        bool
+	mutex            sync.RWMutex
+
+	// Logger functionality
+	logger       tasks.TaskLogger
+	loggerConfig types.TaskLoggerConfig
+}
+
+// NewBaseTypedTask creates a new base typed task
+func NewBaseTypedTask(taskType types.TaskType) *BaseTypedTask {
+	return &BaseTypedTask{
+		taskType: taskType,
+		progress: 0.0,
+		loggerConfig: types.TaskLoggerConfig{
+			BaseLogDir:    "/data/task_logs",
+			MaxTasks:      100,
+			MaxLogSizeMB:  10,
+			EnableConsole: true,
+		},
+	}
+}
+
+// GetType returns the task type
+func (bt *BaseTypedTask) GetType() types.TaskType {
+	return bt.taskType
+}
+
+// IsCancellable returns whether the task can be cancelled
+func (bt *BaseTypedTask) IsCancellable() bool {
+	return true // Most tasks can be cancelled
+}
+
+// Cancel cancels the task
+func (bt *BaseTypedTask) Cancel() error {
+	bt.mutex.Lock()
+	defer bt.mutex.Unlock()
+	bt.cancelled = true
+	return nil
+}
+
+// IsCancelled returns whether the task has been cancelled
+func (bt *BaseTypedTask) IsCancelled() bool {
+	bt.mutex.RLock()
+	defer bt.mutex.RUnlock()
+	return bt.cancelled
+}
+
+// GetProgress returns the current progress (0-100)
+func (bt *BaseTypedTask) GetProgress() float64 {
+	bt.mutex.RLock()
+	defer bt.mutex.RUnlock()
+	return bt.progress
+}
+
+// SetProgress sets the current progress and calls the callback if set
+func (bt *BaseTypedTask) SetProgress(progress float64) {
+	bt.mutex.Lock()
+	callback := bt.progressCallback
+	stage := bt.currentStage
+	bt.progress = progress
+	bt.mutex.Unlock()
+
+	if callback != nil {
+		callback(progress, stage)
+	}
+}
+
+// SetProgressCallback sets the progress callback function
+func (bt *BaseTypedTask) SetProgressCallback(callback func(float64, string)) {
+	bt.mutex.Lock()
+	defer bt.mutex.Unlock()
+	bt.progressCallback = callback
+}
+
+// SetProgressWithStage sets the current progress with a stage description
+func (bt *BaseTypedTask) SetProgressWithStage(progress float64, stage string) {
+	bt.mutex.Lock()
+	callback := bt.progressCallback
+	bt.progress = progress
+	bt.currentStage = stage
+	bt.mutex.Unlock()
+
+	if callback != nil {
+		callback(progress, stage)
+	}
+}
+
+// SetCurrentStage sets the current stage description
+func (bt *BaseTypedTask) SetCurrentStage(stage string) {
+	bt.mutex.Lock()
+	defer bt.mutex.Unlock()
+	bt.currentStage = stage
+}
+
+// GetCurrentStage returns the current stage description
+func (bt *BaseTypedTask) GetCurrentStage() string {
+	bt.mutex.RLock()
+	defer bt.mutex.RUnlock()
+	return bt.currentStage
+}
+
+// SetLoggerConfig sets the logger configuration for this task
+func (bt *BaseTypedTask) SetLoggerConfig(config types.TaskLoggerConfig) {
+	bt.mutex.Lock()
+	defer bt.mutex.Unlock()
+	bt.loggerConfig = config
+}
+
+// convertToTasksLoggerConfig converts types.TaskLoggerConfig to tasks.TaskLoggerConfig
+func convertToTasksLoggerConfig(config types.TaskLoggerConfig) tasks.TaskLoggerConfig {
+	return tasks.TaskLoggerConfig{
+		BaseLogDir:    config.BaseLogDir,
+		MaxTasks:      config.MaxTasks,
+		MaxLogSizeMB:  config.MaxLogSizeMB,
+		EnableConsole: config.EnableConsole,
+	}
+}
+
+// InitializeTaskLogger initializes the task logger with task details (LoggerProvider interface)
+func (bt *BaseTypedTask) InitializeTaskLogger(taskID string, workerID string, params types.TaskParams) error {
+	bt.mutex.Lock()
+	defer bt.mutex.Unlock()
+
+	bt.taskID = taskID
+
+	// Convert the logger config to the tasks package type
+	tasksLoggerConfig := convertToTasksLoggerConfig(bt.loggerConfig)
+
+	logger, err := tasks.NewTaskLogger(taskID, bt.taskType, workerID, params, tasksLoggerConfig)
+	if err != nil {
+		return fmt.Errorf("failed to initialize task logger: %w", err)
+	}
+
+	bt.logger = logger
+	if bt.logger != nil {
+		bt.logger.Info("BaseTypedTask initialized for task %s (type: %s)", taskID, bt.taskType)
+	}
+
+	return nil
+}
+
+// GetTaskLogger returns the task logger (LoggerProvider interface)
+func (bt *BaseTypedTask) GetTaskLogger() types.TaskLogger {
+	bt.mutex.RLock()
+	defer bt.mutex.RUnlock()
+	return bt.logger
+}
+
+// LogInfo logs an info message
+func (bt *BaseTypedTask) LogInfo(message string, args ...interface{}) {
+	bt.mutex.RLock()
+	logger := bt.logger
+	bt.mutex.RUnlock()
+
+	if logger != nil {
+		logger.Info(message, args...)
+	}
+}
+
+// LogWarning logs a warning message
+func (bt *BaseTypedTask) LogWarning(message string, args ...interface{}) {
+	bt.mutex.RLock()
+	logger := bt.logger
+	bt.mutex.RUnlock()
+
+	if logger != nil {
+		logger.Warning(message, args...)
+	}
+}
+
+// LogError logs an error message
+func (bt *BaseTypedTask) LogError(message string, args ...interface{}) {
+	bt.mutex.RLock()
+	logger := bt.logger
+	bt.mutex.RUnlock()
+
+	if logger != nil {
+		logger.Error(message, args...)
+	}
+}
+
+// LogDebug logs a debug message
+func (bt *BaseTypedTask) LogDebug(message string, args ...interface{}) {
+	bt.mutex.RLock()
+	logger := bt.logger
+	bt.mutex.RUnlock()
+
+	if logger != nil {
+		logger.Debug(message, args...)
+	}
+}
+
+// LogWithFields logs a message with structured fields
+func (bt *BaseTypedTask) LogWithFields(level string, message string, fields map[string]interface{}) {
+	bt.mutex.RLock()
+	logger := bt.logger
+	bt.mutex.RUnlock()
+
+	if logger != nil {
+		logger.LogWithFields(level, message, fields)
+	}
+}
+
+// ValidateTyped provides basic validation for typed parameters
+func (bt *BaseTypedTask) ValidateTyped(params *worker_pb.TaskParams) error {
+	if params == nil {
+		return errors.New("task parameters cannot be nil")
+	}
+	if params.VolumeId == 0 {
+		return errors.New("volume_id is required")
+	}
+	if len(params.Sources) == 0 {
+		return errors.New("at least one source is required")
+	}
+	return nil
+}
+
+// EstimateTimeTyped provides a default time estimation
+func (bt *BaseTypedTask) EstimateTimeTyped(params *worker_pb.TaskParams) time.Duration {
+	// Default estimation - concrete tasks should override this
+	return 5 * time.Minute
+}
+
+// ExecuteTyped is a placeholder that concrete tasks must implement
+func (bt *BaseTypedTask) ExecuteTyped(params *worker_pb.TaskParams) error {
+	panic("ExecuteTyped must be implemented by concrete task types")
+}

weed/worker/tasks/base/volume_utils.go

@@ -0,0 +1,36 @@
+package base
+
+import (
+	"github.com/seaweedfs/seaweedfs/weed/admin/topology"
+)
+
+// FindVolumeDisk finds the disk ID where a specific volume is located on a given server.
+// Returns the disk ID and a boolean indicating whether the volume was found.
+// Uses O(1) indexed lookup for optimal performance on large clusters.
+//
+// This is a shared utility function used by multiple task detection algorithms
+// (balance, vacuum, etc.) to locate volumes efficiently.
+//
+// Example usage:
+//
+//	// In balance task: find source disk for a volume that needs to be moved
+//	sourceDisk, found := base.FindVolumeDisk(topology, volumeID, collection, sourceServer)
+//
+//	// In vacuum task: find disk containing volume that needs cleanup
+//	diskID, exists := base.FindVolumeDisk(topology, volumeID, collection, serverID)
+func FindVolumeDisk(activeTopology *topology.ActiveTopology, volumeID uint32, collection string, serverID string) (uint32, bool) {
+	if activeTopology == nil {
+		return 0, false
+	}
+
+	// Use the new O(1) indexed lookup for better performance
+	locations := activeTopology.GetVolumeLocations(volumeID, collection)
+	for _, loc := range locations {
+		if loc.ServerID == serverID {
+			return loc.DiskID, true
+		}
+	}
+
+	// Volume not found on this server
+	return 0, false
+}