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

weed/admin/config/schema.go

@@ -0,0 +1,367 @@
+package config
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"time"
+)
+
+// ConfigWithDefaults defines an interface for configurations that can apply their own defaults
+type ConfigWithDefaults interface {
+	// ApplySchemaDefaults applies default values using the provided schema
+	ApplySchemaDefaults(schema *Schema) error
+	// Validate validates the configuration
+	Validate() error
+}
+
+// FieldType defines the type of a configuration field
+type FieldType string
+
+const (
+	FieldTypeBool     FieldType = "bool"
+	FieldTypeInt      FieldType = "int"
+	FieldTypeDuration FieldType = "duration"
+	FieldTypeInterval FieldType = "interval"
+	FieldTypeString   FieldType = "string"
+	FieldTypeFloat    FieldType = "float"
+)
+
+// FieldUnit defines the unit for display purposes
+type FieldUnit string
+
+const (
+	UnitSeconds FieldUnit = "seconds"
+	UnitMinutes FieldUnit = "minutes"
+	UnitHours   FieldUnit = "hours"
+	UnitDays    FieldUnit = "days"
+	UnitCount   FieldUnit = "count"
+	UnitNone    FieldUnit = ""
+)
+
+// Field defines a configuration field with all its metadata
+type Field struct {
+	// Field identification
+	Name     string    `json:"name"`
+	JSONName string    `json:"json_name"`
+	Type     FieldType `json:"type"`
+
+	// Default value and validation
+	DefaultValue interface{} `json:"default_value"`
+	MinValue     interface{} `json:"min_value,omitempty"`
+	MaxValue     interface{} `json:"max_value,omitempty"`
+	Required     bool        `json:"required"`
+
+	// UI display
+	DisplayName string    `json:"display_name"`
+	Description string    `json:"description"`
+	HelpText    string    `json:"help_text"`
+	Placeholder string    `json:"placeholder"`
+	Unit        FieldUnit `json:"unit"`
+
+	// Form rendering
+	InputType  string `json:"input_type"` // "checkbox", "number", "text", "interval", etc.
+	CSSClasses string `json:"css_classes,omitempty"`
+}
+
+// GetDisplayValue returns the value formatted for display in the specified unit
+func (f *Field) GetDisplayValue(value interface{}) interface{} {
+	if (f.Type == FieldTypeDuration || f.Type == FieldTypeInterval) && f.Unit != UnitSeconds {
+		if duration, ok := value.(time.Duration); ok {
+			switch f.Unit {
+			case UnitMinutes:
+				return int(duration.Minutes())
+			case UnitHours:
+				return int(duration.Hours())
+			case UnitDays:
+				return int(duration.Hours() / 24)
+			}
+		}
+		if seconds, ok := value.(int); ok {
+			switch f.Unit {
+			case UnitMinutes:
+				return seconds / 60
+			case UnitHours:
+				return seconds / 3600
+			case UnitDays:
+				return seconds / (24 * 3600)
+			}
+		}
+	}
+	return value
+}
+
+// GetIntervalDisplayValue returns the value and unit for interval fields
+func (f *Field) GetIntervalDisplayValue(value interface{}) (int, string) {
+	if f.Type != FieldTypeInterval {
+		return 0, "minutes"
+	}
+
+	seconds := 0
+	if duration, ok := value.(time.Duration); ok {
+		seconds = int(duration.Seconds())
+	} else if s, ok := value.(int); ok {
+		seconds = s
+	}
+
+	return SecondsToIntervalValueUnit(seconds)
+}
+
+// SecondsToIntervalValueUnit converts seconds to the most appropriate interval unit
+func SecondsToIntervalValueUnit(totalSeconds int) (int, string) {
+	if totalSeconds == 0 {
+		return 0, "minutes"
+	}
+
+	// Preserve seconds when not divisible by minutes
+	if totalSeconds < 60 || totalSeconds%60 != 0 {
+		return totalSeconds, "seconds"
+	}
+
+	// Check if it's evenly divisible by days
+	if totalSeconds%(24*3600) == 0 {
+		return totalSeconds / (24 * 3600), "days"
+	}
+
+	// Check if it's evenly divisible by hours
+	if totalSeconds%3600 == 0 {
+		return totalSeconds / 3600, "hours"
+	}
+
+	// Default to minutes
+	return totalSeconds / 60, "minutes"
+}
+
+// IntervalValueUnitToSeconds converts interval value and unit to seconds
+func IntervalValueUnitToSeconds(value int, unit string) int {
+	switch unit {
+	case "days":
+		return value * 24 * 3600
+	case "hours":
+		return value * 3600
+	case "minutes":
+		return value * 60
+	case "seconds":
+		return value
+	default:
+		return value * 60 // Default to minutes
+	}
+}
+
+// ParseDisplayValue converts a display value back to the storage format
+func (f *Field) ParseDisplayValue(displayValue interface{}) interface{} {
+	if (f.Type == FieldTypeDuration || f.Type == FieldTypeInterval) && f.Unit != UnitSeconds {
+		if val, ok := displayValue.(int); ok {
+			switch f.Unit {
+			case UnitMinutes:
+				return val * 60
+			case UnitHours:
+				return val * 3600
+			case UnitDays:
+				return val * 24 * 3600
+			}
+		}
+	}
+	return displayValue
+}
+
+// ParseIntervalFormData parses form data for interval fields (value + unit)
+func (f *Field) ParseIntervalFormData(valueStr, unitStr string) (int, error) {
+	if f.Type != FieldTypeInterval {
+		return 0, fmt.Errorf("field %s is not an interval field", f.Name)
+	}
+
+	value := 0
+	if valueStr != "" {
+		var err error
+		value, err = fmt.Sscanf(valueStr, "%d", &value)
+		if err != nil {
+			return 0, fmt.Errorf("invalid interval value: %s", valueStr)
+		}
+	}
+
+	return IntervalValueUnitToSeconds(value, unitStr), nil
+}
+
+// ValidateValue validates a value against the field constraints
+func (f *Field) ValidateValue(value interface{}) error {
+	if f.Required && (value == nil || value == "" || value == 0) {
+		return fmt.Errorf("%s is required", f.DisplayName)
+	}
+
+	if f.MinValue != nil {
+		if !f.compareValues(value, f.MinValue, ">=") {
+			return fmt.Errorf("%s must be >= %v", f.DisplayName, f.MinValue)
+		}
+	}
+
+	if f.MaxValue != nil {
+		if !f.compareValues(value, f.MaxValue, "<=") {
+			return fmt.Errorf("%s must be <= %v", f.DisplayName, f.MaxValue)
+		}
+	}
+
+	return nil
+}
+
+// compareValues compares two values based on the operator
+func (f *Field) compareValues(a, b interface{}, op string) bool {
+	switch f.Type {
+	case FieldTypeInt:
+		aVal, aOk := a.(int)
+		bVal, bOk := b.(int)
+		if !aOk || !bOk {
+			return false
+		}
+		switch op {
+		case ">=":
+			return aVal >= bVal
+		case "<=":
+			return aVal <= bVal
+		}
+	case FieldTypeFloat:
+		aVal, aOk := a.(float64)
+		bVal, bOk := b.(float64)
+		if !aOk || !bOk {
+			return false
+		}
+		switch op {
+		case ">=":
+			return aVal >= bVal
+		case "<=":
+			return aVal <= bVal
+		}
+	}
+	return true
+}
+
+// Schema provides common functionality for configuration schemas
+type Schema struct {
+	Fields []*Field `json:"fields"`
+}
+
+// GetFieldByName returns a field by its JSON name
+func (s *Schema) GetFieldByName(jsonName string) *Field {
+	for _, field := range s.Fields {
+		if field.JSONName == jsonName {
+			return field
+		}
+	}
+	return nil
+}
+
+// ApplyDefaultsToConfig applies defaults to a configuration that implements ConfigWithDefaults
+func (s *Schema) ApplyDefaultsToConfig(config ConfigWithDefaults) error {
+	return config.ApplySchemaDefaults(s)
+}
+
+// ApplyDefaultsToProtobuf applies defaults to protobuf types using reflection
+func (s *Schema) ApplyDefaultsToProtobuf(config interface{}) error {
+	return s.applyDefaultsReflection(config)
+}
+
+// applyDefaultsReflection applies default values using reflection (internal use only)
+// Used for protobuf types and embedded struct handling
+func (s *Schema) applyDefaultsReflection(config interface{}) error {
+	configValue := reflect.ValueOf(config)
+	if configValue.Kind() == reflect.Ptr {
+		configValue = configValue.Elem()
+	}
+
+	if configValue.Kind() != reflect.Struct {
+		return fmt.Errorf("config must be a struct or pointer to struct")
+	}
+
+	configType := configValue.Type()
+
+	for i := 0; i < configValue.NumField(); i++ {
+		field := configValue.Field(i)
+		fieldType := configType.Field(i)
+
+		// Handle embedded structs recursively (before JSON tag check)
+		if field.Kind() == reflect.Struct && fieldType.Anonymous {
+			if !field.CanAddr() {
+				return fmt.Errorf("embedded struct %s is not addressable - config must be a pointer", fieldType.Name)
+			}
+			err := s.applyDefaultsReflection(field.Addr().Interface())
+			if err != nil {
+				return fmt.Errorf("failed to apply defaults to embedded struct %s: %v", fieldType.Name, err)
+			}
+			continue
+		}
+
+		// Get JSON tag name
+		jsonTag := fieldType.Tag.Get("json")
+		if jsonTag == "" {
+			continue
+		}
+
+		// Remove options like ",omitempty"
+		if commaIdx := strings.Index(jsonTag, ","); commaIdx >= 0 {
+			jsonTag = jsonTag[:commaIdx]
+		}
+
+		// Find corresponding schema field
+		schemaField := s.GetFieldByName(jsonTag)
+		if schemaField == nil {
+			continue
+		}
+
+		// Apply default if field is zero value
+		if field.CanSet() && field.IsZero() {
+			defaultValue := reflect.ValueOf(schemaField.DefaultValue)
+			if defaultValue.Type().ConvertibleTo(field.Type()) {
+				field.Set(defaultValue.Convert(field.Type()))
+			}
+		}
+	}
+
+	return nil
+}
+
+// ValidateConfig validates a configuration against the schema
+func (s *Schema) ValidateConfig(config interface{}) []error {
+	var errors []error
+
+	configValue := reflect.ValueOf(config)
+	if configValue.Kind() == reflect.Ptr {
+		configValue = configValue.Elem()
+	}
+
+	if configValue.Kind() != reflect.Struct {
+		errors = append(errors, fmt.Errorf("config must be a struct or pointer to struct"))
+		return errors
+	}
+
+	configType := configValue.Type()
+
+	for i := 0; i < configValue.NumField(); i++ {
+		field := configValue.Field(i)
+		fieldType := configType.Field(i)
+
+		// Get JSON tag name
+		jsonTag := fieldType.Tag.Get("json")
+		if jsonTag == "" {
+			continue
+		}
+
+		// Remove options like ",omitempty"
+		if commaIdx := strings.Index(jsonTag, ","); commaIdx > 0 {
+			jsonTag = jsonTag[:commaIdx]
+		}
+
+		// Find corresponding schema field
+		schemaField := s.GetFieldByName(jsonTag)
+		if schemaField == nil {
+			continue
+		}
+
+		// Validate field value
+		fieldValue := field.Interface()
+		if err := schemaField.ValidateValue(fieldValue); err != nil {
+			errors = append(errors, err)
+		}
+	}
+
+	return errors
+}

weed/admin/config/schema_test.go

@@ -0,0 +1,226 @@
+package config
+
+import (
+	"testing"
+)
+
+// Test structs that mirror the actual configuration structure
+type TestBaseConfigForSchema struct {
+	Enabled             bool `json:"enabled"`
+	ScanIntervalSeconds int  `json:"scan_interval_seconds"`
+	MaxConcurrent       int  `json:"max_concurrent"`
+}
+
+// ApplySchemaDefaults implements ConfigWithDefaults for test struct
+func (c *TestBaseConfigForSchema) ApplySchemaDefaults(schema *Schema) error {
+	return schema.ApplyDefaultsToProtobuf(c)
+}
+
+// Validate implements ConfigWithDefaults for test struct
+func (c *TestBaseConfigForSchema) Validate() error {
+	return nil
+}
+
+type TestTaskConfigForSchema struct {
+	TestBaseConfigForSchema
+	TaskSpecificField    float64 `json:"task_specific_field"`
+	AnotherSpecificField string  `json:"another_specific_field"`
+}
+
+// ApplySchemaDefaults implements ConfigWithDefaults for test struct
+func (c *TestTaskConfigForSchema) ApplySchemaDefaults(schema *Schema) error {
+	return schema.ApplyDefaultsToProtobuf(c)
+}
+
+// Validate implements ConfigWithDefaults for test struct
+func (c *TestTaskConfigForSchema) Validate() error {
+	return nil
+}
+
+func createTestSchema() *Schema {
+	return &Schema{
+		Fields: []*Field{
+			{
+				Name:         "enabled",
+				JSONName:     "enabled",
+				Type:         FieldTypeBool,
+				DefaultValue: true,
+			},
+			{
+				Name:         "scan_interval_seconds",
+				JSONName:     "scan_interval_seconds",
+				Type:         FieldTypeInt,
+				DefaultValue: 1800,
+			},
+			{
+				Name:         "max_concurrent",
+				JSONName:     "max_concurrent",
+				Type:         FieldTypeInt,
+				DefaultValue: 3,
+			},
+			{
+				Name:         "task_specific_field",
+				JSONName:     "task_specific_field",
+				Type:         FieldTypeFloat,
+				DefaultValue: 0.25,
+			},
+			{
+				Name:         "another_specific_field",
+				JSONName:     "another_specific_field",
+				Type:         FieldTypeString,
+				DefaultValue: "default_value",
+			},
+		},
+	}
+}
+
+func TestApplyDefaults_WithEmbeddedStruct(t *testing.T) {
+	schema := createTestSchema()
+
+	// Start with zero values
+	config := &TestTaskConfigForSchema{}
+
+	err := schema.ApplyDefaultsToConfig(config)
+	if err != nil {
+		t.Fatalf("ApplyDefaultsToConfig failed: %v", err)
+	}
+
+	// Verify embedded struct fields got default values
+	if config.Enabled != true {
+		t.Errorf("Expected Enabled=true (default), got %v", config.Enabled)
+	}
+
+	if config.ScanIntervalSeconds != 1800 {
+		t.Errorf("Expected ScanIntervalSeconds=1800 (default), got %v", config.ScanIntervalSeconds)
+	}
+
+	if config.MaxConcurrent != 3 {
+		t.Errorf("Expected MaxConcurrent=3 (default), got %v", config.MaxConcurrent)
+	}
+
+	// Verify task-specific fields got default values
+	if config.TaskSpecificField != 0.25 {
+		t.Errorf("Expected TaskSpecificField=0.25 (default), got %v", config.TaskSpecificField)
+	}
+
+	if config.AnotherSpecificField != "default_value" {
+		t.Errorf("Expected AnotherSpecificField='default_value' (default), got %v", config.AnotherSpecificField)
+	}
+}
+
+func TestApplyDefaults_PartiallySet(t *testing.T) {
+	schema := createTestSchema()
+
+	// Start with some pre-set values
+	config := &TestTaskConfigForSchema{
+		TestBaseConfigForSchema: TestBaseConfigForSchema{
+			Enabled:             true, // Non-zero value, should not be overridden
+			ScanIntervalSeconds: 0,    // Should get default
+			MaxConcurrent:       5,    // Non-zero value, should not be overridden
+		},
+		TaskSpecificField:    0.0,      // Should get default
+		AnotherSpecificField: "custom", // Non-zero value, should not be overridden
+	}
+
+	err := schema.ApplyDefaultsToConfig(config)
+	if err != nil {
+		t.Fatalf("ApplyDefaultsToConfig failed: %v", err)
+	}
+
+	// Verify already-set values are preserved
+	if config.Enabled != true {
+		t.Errorf("Expected Enabled=true (pre-set), got %v", config.Enabled)
+	}
+
+	if config.MaxConcurrent != 5 {
+		t.Errorf("Expected MaxConcurrent=5 (pre-set), got %v", config.MaxConcurrent)
+	}
+
+	if config.AnotherSpecificField != "custom" {
+		t.Errorf("Expected AnotherSpecificField='custom' (pre-set), got %v", config.AnotherSpecificField)
+	}
+
+	// Verify zero values got defaults
+	if config.ScanIntervalSeconds != 1800 {
+		t.Errorf("Expected ScanIntervalSeconds=1800 (default), got %v", config.ScanIntervalSeconds)
+	}
+
+	if config.TaskSpecificField != 0.25 {
+		t.Errorf("Expected TaskSpecificField=0.25 (default), got %v", config.TaskSpecificField)
+	}
+}
+
+func TestApplyDefaults_NonPointer(t *testing.T) {
+	schema := createTestSchema()
+	config := TestTaskConfigForSchema{}
+	// This should fail since we need a pointer to modify the struct
+	err := schema.ApplyDefaultsToProtobuf(config)
+	if err == nil {
+		t.Fatal("Expected error for non-pointer config, but got nil")
+	}
+}
+
+func TestApplyDefaults_NonStruct(t *testing.T) {
+	schema := createTestSchema()
+	var config interface{} = "not a struct"
+	err := schema.ApplyDefaultsToProtobuf(config)
+	if err == nil {
+		t.Fatal("Expected error for non-struct config, but got nil")
+	}
+}
+
+func TestApplyDefaults_EmptySchema(t *testing.T) {
+	schema := &Schema{Fields: []*Field{}}
+	config := &TestTaskConfigForSchema{}
+
+	err := schema.ApplyDefaultsToConfig(config)
+	if err != nil {
+		t.Fatalf("ApplyDefaultsToConfig failed for empty schema: %v", err)
+	}
+
+	// All fields should remain at zero values since no defaults are defined
+	if config.Enabled != false {
+		t.Errorf("Expected Enabled=false (zero value), got %v", config.Enabled)
+	}
+}
+
+func TestApplyDefaults_MissingSchemaField(t *testing.T) {
+	// Schema with fewer fields than the struct
+	schema := &Schema{
+		Fields: []*Field{
+			{
+				Name:         "enabled",
+				JSONName:     "enabled",
+				Type:         FieldTypeBool,
+				DefaultValue: true,
+			},
+			// Note: missing scan_interval_seconds and other fields
+		},
+	}
+
+	config := &TestTaskConfigForSchema{}
+	err := schema.ApplyDefaultsToConfig(config)
+	if err != nil {
+		t.Fatalf("ApplyDefaultsToConfig failed: %v", err)
+	}
+
+	// Only the field with a schema definition should get a default
+	if config.Enabled != true {
+		t.Errorf("Expected Enabled=true (has schema), got %v", config.Enabled)
+	}
+
+	// Fields without schema should remain at zero values
+	if config.ScanIntervalSeconds != 0 {
+		t.Errorf("Expected ScanIntervalSeconds=0 (no schema), got %v", config.ScanIntervalSeconds)
+	}
+}
+
+func BenchmarkApplyDefaults(b *testing.B) {
+	schema := createTestSchema()
+	config := &TestTaskConfigForSchema{}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = schema.ApplyDefaultsToConfig(config)
+	}
+}