fix: support string duration values in JSON/YAML config files

time.Duration fields like watch-progress-notify-interval do not
properly unmarshal from JSON strings (e.g. "1m"). This is because
time.Duration is just an int64 and does not implement json.Unmarshaler.

Add preprocessDurationFields() that converts string duration values
to nanosecond integers before YAML/JSON unmarshaling. This applies
to all duration config fields, matching the behavior of command-line
flags which use time.ParseDuration.

Fixes #20342

Signed-off-by: majianhan <majianhan@kylinos.cn>

Author: majianhan

server/embed/config.go

@@ -16,6 +16,7 @@ package embed
 
 import (
 	"crypto/tls"
+	"encoding/json"
 	"errors"
 	"flag"
 	"fmt"
@@ -771,12 +772,74 @@ func ConfigFromFile(path string) (*Config, error) {
 	return &cfg.Config, nil
 }
 
+// durationFieldKeys lists all JSON keys in Config that correspond to time.Duration fields.
+// String values (e.g. "1m", "500ms") are converted to nanosecond integers before unmarshaling,
+// because time.Duration does not implement json.Unmarshaler.
+var durationFieldKeys = map[string]bool{
+	"backend-batch-interval":          true,
+	"grpc-keepalive-min-time":         true,
+	"grpc-keepalive-interval":         true,
+	"grpc-keepalive-timeout":          true,
+	"corrupt-check-time":              true,
+	"compact-hash-check-time":         true,
+	"compaction-sleep-interval":       true,
+	"watch-progress-notify-interval":  true,
+	"warning-apply-duration":          true,
+	"warning-unary-request-duration":  true,
+	"downgrade-check-time":            true,
+}
+
+// preprocessDurationFields converts string duration values (e.g. "1m", "500ms") to
+// nanosecond integers so that time.Duration fields unmarshal correctly from JSON/YAML.
+func preprocessDurationFields(b []byte) ([]byte, error) {
+	var raw map[string]json.RawMessage
+	if err := yaml.Unmarshal(b, &raw); err != nil {
+		// If parsing as a map fails, return the original bytes and let the
+		// caller handle the error during normal unmarshaling.
+		return b, nil
+	}
+
+	modified := false
+	for key, val := range raw {
+		if !durationFieldKeys[key] {
+			continue
+		}
+		// Try to unmarshal as a string (e.g. "1m", "10s").
+		var s string
+		if err := json.Unmarshal(val, &s); err != nil {
+			// Not a string; might already be a number, which is fine.
+			continue
+		}
+		d, err := time.ParseDuration(s)
+		if err != nil {
+			return nil, fmt.Errorf("invalid duration value for %q: %w", key, err)
+		}
+		nsBytes, err := json.Marshal(d.Nanoseconds())
+		if err != nil {
+			return nil, err
+		}
+		raw[key] = nsBytes
+		modified = true
+	}
+
+	if !modified {
+		return b, nil
+	}
+
+	return yaml.Marshal(raw)
+}
+
 func (cfg *configYAML) configFromFile(path string) error {
 	b, err := os.ReadFile(path)
 	if err != nil {
 		return err
 	}
 
+	b, err = preprocessDurationFields(b)
+	if err != nil {
+		return err
+	}
+
 	defaultInitialCluster := cfg.InitialCluster
 
 	err = yaml.Unmarshal(b, cfg)

server/embed/config_test.go

@@ -16,6 +16,7 @@ package embed
 
 import (
 	"crypto/tls"
+	"encoding/json"
 	"errors"
 	"flag"
 	"fmt"
@@ -944,3 +945,121 @@ func TestFastLeaseKeepAliveValidate(t *testing.T) {
 		})
 	}
 }
+
+func TestConfigFileDurationFields(t *testing.T) {
+	testCases := []struct {
+		name      string
+		config    map[string]any
+		expectErr bool
+		check     func(t *testing.T, cfg *Config)
+	}{
+		{
+			name: "string duration for watch-progress-notify-interval",
+			config: map[string]any{
+				"watch-progress-notify-interval": "1m",
+			},
+			check: func(t *testing.T, cfg *Config) {
+				require.Equal(t, time.Minute, cfg.WatchProgressNotifyInterval)
+			},
+		},
+		{
+			name: "numeric duration (nanoseconds) for watch-progress-notify-interval",
+			config: map[string]any{
+				"watch-progress-notify-interval": float64(time.Minute),
+			},
+			check: func(t *testing.T, cfg *Config) {
+				require.Equal(t, time.Minute, cfg.WatchProgressNotifyInterval)
+			},
+		},
+		{
+			name: "string durations for multiple fields",
+			config: map[string]any{
+				"watch-progress-notify-interval": "30s",
+				"backend-batch-interval":         "500ms",
+				"grpc-keepalive-min-time":        "5s",
+				"grpc-keepalive-interval":        "2h",
+				"grpc-keepalive-timeout":         "20s",
+				"corrupt-check-time":             "4m",
+				"compact-hash-check-time":        "2m",
+				"compaction-sleep-interval":      "100ms",
+				"warning-apply-duration":         "200ms",
+				"warning-unary-request-duration":  "300ms",
+				"downgrade-check-time":           "5s",
+			},
+			check: func(t *testing.T, cfg *Config) {
+				require.Equal(t, 30*time.Second, cfg.WatchProgressNotifyInterval)
+				require.Equal(t, 500*time.Millisecond, cfg.BackendBatchInterval)
+				require.Equal(t, 5*time.Second, cfg.GRPCKeepAliveMinTime)
+				require.Equal(t, 2*time.Hour, cfg.GRPCKeepAliveInterval)
+				require.Equal(t, 20*time.Second, cfg.GRPCKeepAliveTimeout)
+				require.Equal(t, 4*time.Minute, cfg.CorruptCheckTime)
+				require.Equal(t, 2*time.Minute, cfg.CompactHashCheckTime)
+				require.Equal(t, 100*time.Millisecond, cfg.CompactionSleepInterval)
+				require.Equal(t, 200*time.Millisecond, cfg.WarningApplyDuration)
+				require.Equal(t, 300*time.Millisecond, cfg.WarningUnaryRequestDuration)
+				require.Equal(t, 5*time.Second, cfg.DowngradeCheckTime)
+			},
+		},
+		{
+			name: "invalid duration string",
+			config: map[string]any{
+				"watch-progress-notify-interval": "not-a-duration",
+			},
+			expectErr: true,
+		},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			b, err := json.Marshal(tc.config)
+			require.NoError(t, err)
+
+			tmpfile := mustCreateCfgFile(t, b)
+			defer os.Remove(tmpfile.Name())
+
+			cfg, err := ConfigFromFile(tmpfile.Name())
+			if tc.expectErr {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			tc.check(t, cfg)
+		})
+	}
+}
+
+func TestPreprocessDurationFields(t *testing.T) {
+	testCases := []struct {
+		name      string
+		input     string
+		expectErr bool
+	}{
+		{
+			name:  "string duration value",
+			input: `{"watch-progress-notify-interval": "1m"}`,
+		},
+		{
+			name:  "numeric duration value passes through",
+			input: `{"watch-progress-notify-interval": 60000000000}`,
+		},
+		{
+			name:  "non-duration field unchanged",
+			input: `{"name": "my-etcd"}`,
+		},
+		{
+			name:      "invalid duration string",
+			input:     `{"watch-progress-notify-interval": "invalid"}`,
+			expectErr: true,
+		},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result, err := preprocessDurationFields([]byte(tc.input))
+			if tc.expectErr {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			require.NotEmpty(t, result)
+		})
+	}
+}