refactor

weed/worker/tasks/erasure_coding/config.go

@@ -0,0 +1,125 @@
+package erasure_coding
+
+import (
+	"github.com/seaweedfs/seaweedfs/weed/admin/config"
+	"github.com/seaweedfs/seaweedfs/weed/worker/tasks/base"
+)
+
+// Config extends BaseConfig with erasure coding specific settings
+type Config struct {
+	base.BaseConfig
+	QuietForSeconds  int     `json:"quiet_for_seconds"`
+	FullnessRatio    float64 `json:"fullness_ratio"`
+	CollectionFilter string  `json:"collection_filter"`
+}
+
+// NewDefaultConfig creates a new default erasure coding configuration
+func NewDefaultConfig() *Config {
+	return &Config{
+		BaseConfig: base.BaseConfig{
+			Enabled:             true,
+			ScanIntervalSeconds: 60 * 60, // 1 hour
+			MaxConcurrent:       1,
+		},
+		QuietForSeconds:  300, // 5 minutes
+		FullnessRatio:    0.8, // 80%
+		CollectionFilter: "",
+	}
+}
+
+// GetConfigSpec returns the configuration schema for erasure coding tasks
+func GetConfigSpec() base.ConfigSpec {
+	return base.ConfigSpec{
+		Fields: []*config.Field{
+			{
+				Name:         "enabled",
+				JSONName:     "enabled",
+				Type:         config.FieldTypeBool,
+				DefaultValue: true,
+				Required:     false,
+				DisplayName:  "Enable Erasure Coding Tasks",
+				Description:  "Whether erasure coding tasks should be automatically created",
+				HelpText:     "Toggle this to enable or disable automatic erasure coding task generation",
+				InputType:    "checkbox",
+				CSSClasses:   "form-check-input",
+			},
+			{
+				Name:         "scan_interval_seconds",
+				JSONName:     "scan_interval_seconds",
+				Type:         config.FieldTypeInterval,
+				DefaultValue: 60 * 60,
+				MinValue:     10 * 60,
+				MaxValue:     24 * 60 * 60,
+				Required:     true,
+				DisplayName:  "Scan Interval",
+				Description:  "How often to scan for volumes needing erasure coding",
+				HelpText:     "The system will check for volumes that need erasure coding at this interval",
+				Placeholder:  "1",
+				Unit:         config.UnitHours,
+				InputType:    "interval",
+				CSSClasses:   "form-control",
+			},
+			{
+				Name:         "max_concurrent",
+				JSONName:     "max_concurrent",
+				Type:         config.FieldTypeInt,
+				DefaultValue: 1,
+				MinValue:     1,
+				MaxValue:     5,
+				Required:     true,
+				DisplayName:  "Max Concurrent Tasks",
+				Description:  "Maximum number of erasure coding tasks that can run simultaneously",
+				HelpText:     "Limits the number of erasure coding operations running at the same time",
+				Placeholder:  "1 (default)",
+				Unit:         config.UnitCount,
+				InputType:    "number",
+				CSSClasses:   "form-control",
+			},
+			{
+				Name:         "quiet_for_seconds",
+				JSONName:     "quiet_for_seconds",
+				Type:         config.FieldTypeInterval,
+				DefaultValue: 300,
+				MinValue:     60,
+				MaxValue:     3600,
+				Required:     true,
+				DisplayName:  "Quiet Period",
+				Description:  "Minimum time volume must be quiet before erasure coding",
+				HelpText:     "Volume must not be modified for this duration before erasure coding",
+				Placeholder:  "5",
+				Unit:         config.UnitMinutes,
+				InputType:    "interval",
+				CSSClasses:   "form-control",
+			},
+			{
+				Name:         "fullness_ratio",
+				JSONName:     "fullness_ratio",
+				Type:         config.FieldTypeFloat,
+				DefaultValue: 0.8,
+				MinValue:     0.1,
+				MaxValue:     1.0,
+				Required:     true,
+				DisplayName:  "Fullness Ratio",
+				Description:  "Minimum fullness ratio to trigger erasure coding",
+				HelpText:     "Only volumes with this fullness ratio or higher will be erasure coded",
+				Placeholder:  "0.80 (80%)",
+				Unit:         config.UnitNone,
+				InputType:    "number",
+				CSSClasses:   "form-control",
+			},
+			{
+				Name:         "collection_filter",
+				JSONName:     "collection_filter",
+				Type:         config.FieldTypeString,
+				DefaultValue: "",
+				Required:     false,
+				DisplayName:  "Collection Filter",
+				Description:  "Only process volumes from specific collections",
+				HelpText:     "Leave empty to process all collections, or specify collection name",
+				Placeholder:  "my_collection",
+				InputType:    "text",
+				CSSClasses:   "form-control",
+			},
+		},
+	}
+}

weed/worker/tasks/erasure_coding/detection.go

@@ -0,0 +1,126 @@
+package erasure_coding
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/worker/tasks/base"
+	"github.com/seaweedfs/seaweedfs/weed/worker/types"
+)
+
+// Detection implements the detection logic for erasure coding tasks
+func Detection(metrics []*types.VolumeHealthMetrics, clusterInfo *types.ClusterInfo, config base.TaskConfig) ([]*types.TaskDetectionResult, error) {
+	if !config.IsEnabled() {
+		return nil, nil
+	}
+
+	ecConfig := config.(*Config)
+	var results []*types.TaskDetectionResult
+	now := time.Now()
+	quietThreshold := time.Duration(ecConfig.QuietForSeconds) * time.Second
+	minSizeBytes := uint64(100) * 1024 * 1024 // 100MB minimum
+
+	for _, metric := range metrics {
+		// Skip if already EC volume
+		if metric.IsECVolume {
+			continue
+		}
+
+		// Check minimum size requirement
+		if metric.Size < minSizeBytes {
+			continue
+		}
+
+		// Check collection filter if specified
+		if ecConfig.CollectionFilter != "" {
+			// Parse comma-separated collections
+			allowedCollections := make(map[string]bool)
+			for _, collection := range strings.Split(ecConfig.CollectionFilter, ",") {
+				allowedCollections[strings.TrimSpace(collection)] = true
+			}
+			// Skip if volume's collection is not in the allowed list
+			if !allowedCollections[metric.Collection] {
+				continue
+			}
+		}
+
+		// Check quiet duration and fullness criteria
+		if metric.Age >= quietThreshold && metric.FullnessRatio >= ecConfig.FullnessRatio {
+			result := &types.TaskDetectionResult{
+				TaskType:   types.TaskTypeErasureCoding,
+				VolumeID:   metric.VolumeID,
+				Server:     metric.Server,
+				Collection: metric.Collection,
+				Priority:   types.TaskPriorityLow, // EC is not urgent
+				Reason: fmt.Sprintf("Volume meets EC criteria: quiet for %.1fs (>%ds), fullness=%.1f%% (>%.1f%%), size=%.1fMB (>100MB)",
+					metric.Age.Seconds(), ecConfig.QuietForSeconds, metric.FullnessRatio*100, ecConfig.FullnessRatio*100,
+					float64(metric.Size)/(1024*1024)),
+				Parameters: map[string]interface{}{
+					"age_seconds":    int(metric.Age.Seconds()),
+					"fullness_ratio": metric.FullnessRatio,
+					"size_mb":        int(metric.Size / (1024 * 1024)),
+				},
+				ScheduleAt: now,
+			}
+			results = append(results, result)
+		}
+	}
+
+	return results, nil
+}
+
+// Scheduling implements the scheduling logic for erasure coding tasks
+func Scheduling(task *types.Task, runningTasks []*types.Task, availableWorkers []*types.Worker, config base.TaskConfig) bool {
+	ecConfig := config.(*Config)
+
+	// Check if we have available workers
+	if len(availableWorkers) == 0 {
+		return false
+	}
+
+	// Count running EC tasks
+	runningCount := 0
+	for _, runningTask := range runningTasks {
+		if runningTask.Type == types.TaskTypeErasureCoding {
+			runningCount++
+		}
+	}
+
+	// Check concurrency limit
+	if runningCount >= ecConfig.MaxConcurrent {
+		return false
+	}
+
+	// Check if any worker can handle EC tasks
+	for _, worker := range availableWorkers {
+		for _, capability := range worker.Capabilities {
+			if capability == types.TaskTypeErasureCoding {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+// CreateTask creates a new erasure coding task instance
+func CreateTask(params types.TaskParams) (types.TaskInterface, error) {
+	// Extract configuration from params
+	var config *Config
+	if configData, ok := params.Parameters["config"]; ok {
+		if configMap, ok := configData.(map[string]interface{}); ok {
+			config = &Config{}
+			if err := config.FromMap(configMap); err != nil {
+				return nil, fmt.Errorf("failed to parse erasure coding config: %v", err)
+			}
+		}
+	}
+
+	if config == nil {
+		config = NewDefaultConfig()
+	}
+
+	// Create and return the erasure coding task using existing Task type
+	return NewTask(params.Server, params.VolumeID), nil
+}

weed/worker/tasks/erasure_coding/ec.go

@@ -7,13 +7,11 @@ import (
 	"math"
 	"os"
 	"path/filepath"
-	"strings"
 	"sync"
 	"time"
 
 	"google.golang.org/grpc"
 
-	"github.com/seaweedfs/seaweedfs/weed/admin/config"
 	"github.com/seaweedfs/seaweedfs/weed/glog"
 	"github.com/seaweedfs/seaweedfs/weed/operation"
 	"github.com/seaweedfs/seaweedfs/weed/pb"
@@ -23,7 +21,6 @@ import (
 	"github.com/seaweedfs/seaweedfs/weed/storage/needle"
 	"github.com/seaweedfs/seaweedfs/weed/storage/volume_info"
 	"github.com/seaweedfs/seaweedfs/weed/worker/tasks"
-	"github.com/seaweedfs/seaweedfs/weed/worker/tasks/base"
 	"github.com/seaweedfs/seaweedfs/weed/worker/types"
 	"google.golang.org/grpc/credentials/insecure"
 )
@@ -1019,270 +1016,3 @@ func (t *Task) mountShardOnServer(targetServer pb.ServerAddress, shardId uint32)
 	glog.V(1).Infof("MOUNT SUCCESS: Shard %d successfully mounted on %s", shardId, targetServer)
 	return nil
 }
-
-// ErasureCodingConfig extends BaseConfig with erasure coding specific settings
-type ErasureCodingConfig struct {
-	base.BaseConfig
-	QuietForSeconds  int     `json:"quiet_for_seconds"`
-	FullnessRatio    float64 `json:"fullness_ratio"`
-	CollectionFilter string  `json:"collection_filter"`
-}
-
-// ecDetection implements the detection logic for erasure coding tasks
-func ecDetection(metrics []*types.VolumeHealthMetrics, clusterInfo *types.ClusterInfo, config base.TaskConfig) ([]*types.TaskDetectionResult, error) {
-	if !config.IsEnabled() {
-		return nil, nil
-	}
-
-	ecConfig := config.(*ErasureCodingConfig)
-	var results []*types.TaskDetectionResult
-	now := time.Now()
-	quietThreshold := time.Duration(ecConfig.QuietForSeconds) * time.Second
-	minSizeBytes := uint64(100) * 1024 * 1024 // 100MB minimum
-
-	for _, metric := range metrics {
-		// Skip if already EC volume
-		if metric.IsECVolume {
-			continue
-		}
-
-		// Check minimum size requirement
-		if metric.Size < minSizeBytes {
-			continue
-		}
-
-		// Check collection filter if specified
-		if ecConfig.CollectionFilter != "" {
-			// Parse comma-separated collections
-			allowedCollections := make(map[string]bool)
-			for _, collection := range strings.Split(ecConfig.CollectionFilter, ",") {
-				allowedCollections[strings.TrimSpace(collection)] = true
-			}
-			// Skip if volume's collection is not in the allowed list
-			if !allowedCollections[metric.Collection] {
-				continue
-			}
-		}
-
-		// Check quiet duration and fullness criteria
-		if metric.Age >= quietThreshold && metric.FullnessRatio >= ecConfig.FullnessRatio {
-			result := &types.TaskDetectionResult{
-				TaskType:   types.TaskTypeErasureCoding,
-				VolumeID:   metric.VolumeID,
-				Server:     metric.Server,
-				Collection: metric.Collection,
-				Priority:   types.TaskPriorityLow, // EC is not urgent
-				Reason: fmt.Sprintf("Volume meets EC criteria: quiet for %.1fs (>%ds), fullness=%.1f%% (>%.1f%%), size=%.1fMB (>100MB)",
-					metric.Age.Seconds(), ecConfig.QuietForSeconds, metric.FullnessRatio*100, ecConfig.FullnessRatio*100,
-					float64(metric.Size)/(1024*1024)),
-				Parameters: map[string]interface{}{
-					"age_seconds":    int(metric.Age.Seconds()),
-					"fullness_ratio": metric.FullnessRatio,
-					"size_mb":        int(metric.Size / (1024 * 1024)),
-				},
-				ScheduleAt: now,
-			}
-			results = append(results, result)
-		}
-	}
-
-	return results, nil
-}
-
-// ecScheduling implements the scheduling logic for erasure coding tasks
-func ecScheduling(task *types.Task, runningTasks []*types.Task, availableWorkers []*types.Worker, config base.TaskConfig) bool {
-	ecConfig := config.(*ErasureCodingConfig)
-
-	// Check if we have available workers
-	if len(availableWorkers) == 0 {
-		return false
-	}
-
-	// Count running EC tasks
-	runningCount := 0
-	for _, runningTask := range runningTasks {
-		if runningTask.Type == types.TaskTypeErasureCoding {
-			runningCount++
-		}
-	}
-
-	// Check concurrency limit
-	if runningCount >= ecConfig.MaxConcurrent {
-		return false
-	}
-
-	// Check if any worker can handle EC tasks
-	for _, worker := range availableWorkers {
-		for _, capability := range worker.Capabilities {
-			if capability == types.TaskTypeErasureCoding {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
-// createErasureCodingTask creates a new erasure coding task instance
-func createErasureCodingTask(params types.TaskParams) (types.TaskInterface, error) {
-	// Extract configuration from params
-	var config *ErasureCodingConfig
-	if configData, ok := params.Parameters["config"]; ok {
-		if configMap, ok := configData.(map[string]interface{}); ok {
-			config = &ErasureCodingConfig{}
-			if err := config.FromMap(configMap); err != nil {
-				return nil, fmt.Errorf("failed to parse erasure coding config: %v", err)
-			}
-		}
-	}
-
-	if config == nil {
-		config = &ErasureCodingConfig{
-			BaseConfig: base.BaseConfig{
-				Enabled:             true,
-				ScanIntervalSeconds: 60 * 60, // 1 hour
-				MaxConcurrent:       1,
-			},
-			QuietForSeconds:  300, // 5 minutes
-			FullnessRatio:    0.8, // 80%
-			CollectionFilter: "",
-		}
-	}
-
-	// Create and return the erasure coding task using existing Task type
-	return NewTask(params.Server, params.VolumeID), nil
-}
-
-// getErasureCodingConfigSpec returns the configuration schema for erasure coding tasks
-func getErasureCodingConfigSpec() base.ConfigSpec {
-	return base.ConfigSpec{
-		Fields: []*config.Field{
-			{
-				Name:         "enabled",
-				JSONName:     "enabled",
-				Type:         config.FieldTypeBool,
-				DefaultValue: true,
-				Required:     false,
-				DisplayName:  "Enable Erasure Coding Tasks",
-				Description:  "Whether erasure coding tasks should be automatically created",
-				HelpText:     "Toggle this to enable or disable automatic erasure coding task generation",
-				InputType:    "checkbox",
-				CSSClasses:   "form-check-input",
-			},
-			{
-				Name:         "scan_interval_seconds",
-				JSONName:     "scan_interval_seconds",
-				Type:         config.FieldTypeInterval,
-				DefaultValue: 60 * 60,
-				MinValue:     10 * 60,
-				MaxValue:     24 * 60 * 60,
-				Required:     true,
-				DisplayName:  "Scan Interval",
-				Description:  "How often to scan for volumes needing erasure coding",
-				HelpText:     "The system will check for volumes that need erasure coding at this interval",
-				Placeholder:  "1",
-				Unit:         config.UnitHours,
-				InputType:    "interval",
-				CSSClasses:   "form-control",
-			},
-			{
-				Name:         "max_concurrent",
-				JSONName:     "max_concurrent",
-				Type:         config.FieldTypeInt,
-				DefaultValue: 1,
-				MinValue:     1,
-				MaxValue:     5,
-				Required:     true,
-				DisplayName:  "Max Concurrent Tasks",
-				Description:  "Maximum number of erasure coding tasks that can run simultaneously",
-				HelpText:     "Limits the number of erasure coding operations running at the same time",
-				Placeholder:  "1 (default)",
-				Unit:         config.UnitCount,
-				InputType:    "number",
-				CSSClasses:   "form-control",
-			},
-			{
-				Name:         "quiet_for_seconds",
-				JSONName:     "quiet_for_seconds",
-				Type:         config.FieldTypeInterval,
-				DefaultValue: 300,
-				MinValue:     60,
-				MaxValue:     3600,
-				Required:     true,
-				DisplayName:  "Quiet Period",
-				Description:  "Minimum time volume must be quiet before erasure coding",
-				HelpText:     "Volume must not be modified for this duration before erasure coding",
-				Placeholder:  "5",
-				Unit:         config.UnitMinutes,
-				InputType:    "interval",
-				CSSClasses:   "form-control",
-			},
-			{
-				Name:         "fullness_ratio",
-				JSONName:     "fullness_ratio",
-				Type:         config.FieldTypeFloat,
-				DefaultValue: 0.8,
-				MinValue:     0.1,
-				MaxValue:     1.0,
-				Required:     true,
-				DisplayName:  "Fullness Ratio",
-				Description:  "Minimum fullness ratio to trigger erasure coding",
-				HelpText:     "Only volumes with this fullness ratio or higher will be erasure coded",
-				Placeholder:  "0.80 (80%)",
-				Unit:         config.UnitNone,
-				InputType:    "number",
-				CSSClasses:   "form-control",
-			},
-			{
-				Name:         "collection_filter",
-				JSONName:     "collection_filter",
-				Type:         config.FieldTypeString,
-				DefaultValue: "",
-				Required:     false,
-				DisplayName:  "Collection Filter",
-				Description:  "Only process volumes from specific collections",
-				HelpText:     "Leave empty to process all collections, or specify collection name",
-				Placeholder:  "my_collection",
-				InputType:    "text",
-				CSSClasses:   "form-control",
-			},
-		},
-	}
-}
-
-// initErasureCoding registers the refactored erasure coding task
-func initErasureCoding() {
-	// Create configuration instance
-	config := &ErasureCodingConfig{
-		BaseConfig: base.BaseConfig{
-			Enabled:             true,
-			ScanIntervalSeconds: 60 * 60, // 1 hour
-			MaxConcurrent:       1,
-		},
-		QuietForSeconds:  300, // 5 minutes
-		FullnessRatio:    0.8, // 80%
-		CollectionFilter: "",
-	}
-
-	// Create complete task definition
-	taskDef := &base.TaskDefinition{
-		Type:         types.TaskTypeErasureCoding,
-		Name:         "erasure_coding",
-		DisplayName:  "Erasure Coding",
-		Description:  "Applies erasure coding to volumes for data protection",
-		Icon:         "fas fa-shield-alt text-success",
-		Capabilities: []string{"erasure_coding", "data_protection"},
-
-		Config:         config,
-		ConfigSpec:     getErasureCodingConfigSpec(),
-		CreateTask:     createErasureCodingTask,
-		DetectionFunc:  ecDetection,
-		ScanInterval:   1 * time.Hour,
-		SchedulingFunc: ecScheduling,
-		MaxConcurrent:  1,
-		RepeatInterval: 24 * time.Hour,
-	}
-
-	// Register everything with a single function call!
-	base.RegisterTask(taskDef)
-}

weed/worker/tasks/erasure_coding/ec_register.go

@@ -1,7 +1,41 @@
 package erasure_coding
 
+import (
+	"time"
+
+	"github.com/seaweedfs/seaweedfs/weed/worker/tasks/base"
+	"github.com/seaweedfs/seaweedfs/weed/worker/types"
+)
+
 // Auto-register this task when the package is imported
 func init() {
-	// Use new architecture instead of old registration
-	initErasureCoding()
+	RegisterErasureCodingTask()
+}
+
+// RegisterErasureCodingTask registers the erasure coding task with the new architecture
+func RegisterErasureCodingTask() {
+	// Create configuration instance
+	config := NewDefaultConfig()
+
+	// Create complete task definition
+	taskDef := &base.TaskDefinition{
+		Type:         types.TaskTypeErasureCoding,
+		Name:         "erasure_coding",
+		DisplayName:  "Erasure Coding",
+		Description:  "Applies erasure coding to volumes for data protection",
+		Icon:         "fas fa-shield-alt text-success",
+		Capabilities: []string{"erasure_coding", "data_protection"},
+
+		Config:         config,
+		ConfigSpec:     GetConfigSpec(),
+		CreateTask:     CreateTask,
+		DetectionFunc:  Detection,
+		ScanInterval:   1 * time.Hour,
+		SchedulingFunc: Scheduling,
+		MaxConcurrent:  1,
+		RepeatInterval: 24 * time.Hour,
+	}
+
+	// Register everything with a single function call!
+	base.RegisterTask(taskDef)
 }