seaweedfs/weed/admin/maintenance/config_verification.go

package maintenance

import (
	"fmt"

	"github.com/seaweedfs/seaweedfs/weed/pb/worker_pb"
)

// VerifyProtobufConfig demonstrates that the protobuf configuration system is working
func VerifyProtobufConfig() error {
	// Create configuration manager
	configManager := NewMaintenanceConfigManager()
	config := configManager.GetConfig()

	// Verify basic configuration
	if !config.Enabled {
		return fmt.Errorf("expected config to be enabled by default")
	}

	if config.ScanIntervalSeconds != 30*60 {
		return fmt.Errorf("expected scan interval to be 1800 seconds, got %d", config.ScanIntervalSeconds)
	}

	// Verify policy configuration
	if config.Policy == nil {
		return fmt.Errorf("expected policy to be configured")
	}

	if config.Policy.GlobalMaxConcurrent != 4 {
		return fmt.Errorf("expected global max concurrent to be 4, got %d", config.Policy.GlobalMaxConcurrent)
	}

	// Note: Task policies are now only configured for implemented task types
	// Vacuum, balance, and replication task configs have been removed

	// Verify erasure coding configuration
	ecPolicy := config.Policy.TaskPolicies["erasure_coding"]
	if ecPolicy == nil {
		return fmt.Errorf("expected EC policy to be configured")
	}

	ecConfig := ecPolicy.GetErasureCodingConfig()
	if ecConfig == nil {
		return fmt.Errorf("expected EC config to be accessible")
	}

	// Verify configurable EC fields only
	if ecConfig.FullnessRatio <= 0 || ecConfig.FullnessRatio > 1 {
		return fmt.Errorf("expected EC config to have valid fullness ratio (0-1), got %f", ecConfig.FullnessRatio)
	}

	return nil
}

// GetProtobufConfigSummary returns a summary of the current protobuf configuration
func GetProtobufConfigSummary() string {
	configManager := NewMaintenanceConfigManager()
	config := configManager.GetConfig()

	summary := fmt.Sprintf("SeaweedFS Protobuf Maintenance Configuration:\n")
	summary += fmt.Sprintf("  Enabled: %v\n", config.Enabled)
	summary += fmt.Sprintf("  Scan Interval: %d seconds\n", config.ScanIntervalSeconds)
	summary += fmt.Sprintf("  Max Retries: %d\n", config.MaxRetries)
	summary += fmt.Sprintf("  Global Max Concurrent: %d\n", config.Policy.GlobalMaxConcurrent)
	summary += fmt.Sprintf("  Task Policies: %d configured\n", len(config.Policy.TaskPolicies))

	for taskType, policy := range config.Policy.TaskPolicies {
		summary += fmt.Sprintf("    %s: enabled=%v, max_concurrent=%d\n",
			taskType, policy.Enabled, policy.MaxConcurrent)
	}

	return summary
}

// CreateCustomConfig demonstrates creating a custom protobuf configuration
func CreateCustomConfig() *worker_pb.MaintenanceConfig {
	return &worker_pb.MaintenanceConfig{
		Enabled:             true,
		ScanIntervalSeconds: 60 * 60, // 1 hour
		MaxRetries:          5,
		Policy: &worker_pb.MaintenancePolicy{
			GlobalMaxConcurrent: 8,
			TaskPolicies: map[string]*worker_pb.TaskPolicy{
				"custom_erasure_coding": {
					Enabled:       true,
					MaxConcurrent: 2,
					TaskConfig: &worker_pb.TaskPolicy_ErasureCodingConfig{
						ErasureCodingConfig: &worker_pb.ErasureCodingTaskConfig{
							FullnessRatio:    0.95,
							QuietForSeconds:  1800,
							MinVolumeSizeMb:  200,
							CollectionFilter: "",
						},
					},
				},
			},
		},
	}
}