fix: add Valkey server type detection support

Author: destinyoooo

internal/client/func.go

@@ -2,6 +2,7 @@ package client
 
 import (
 	"bytes"
+	"errors"
 	"strings"
 
 	"RedisShake/internal/client/proto"
@@ -26,3 +27,30 @@ func (r *Redis) IsCluster() bool {
 	reply := r.DoWithStringReply("INFO", "Cluster")
 	return strings.Contains(reply, "cluster_enabled:1")
 }
+
+// ParseServerVersion parses the server info string and returns whether the server is Valkey.
+// Returns true if the server is Valkey, false if it's Redis, and an error if neither is found.
+func ParseServerVersion(serverInfo string) (isValkey bool, err error) {
+	for _, line := range strings.Split(serverInfo, "\n") {
+		line = strings.TrimSpace(line)
+		if strings.HasPrefix(line, "valkey_version:") {
+			return true, nil
+		}
+		if strings.HasPrefix(line, "redis_version:") {
+			return false, nil
+		}
+	}
+	return false, errors.New("server version not found in info string")
+}
+
+// IsValkey detects whether the connected server is Valkey by checking the server info.
+// Returns true if the server is Valkey, false if it's Redis.
+func (r *Redis) IsValkey() bool {
+	reply := r.DoWithStringReply("INFO", "server")
+	isValkey, err := ParseServerVersion(reply)
+	if err != nil {
+		log.Warnf("failed to detect server type: %v, assuming Redis", err)
+		return false
+	}
+	return isValkey
+}

internal/client/func_test.go

@@ -0,0 +1,128 @@
+package client
+
+import (
+	"testing"
+)
+
+func TestParseServerVersion(t *testing.T) {
+	tests := []struct {
+		name       string
+		serverInfo string
+		want       bool
+		wantErr    bool
+	}{
+		{
+			name: "Valkey 9.x",
+			serverInfo: `# Server
+valkey_version:9.0.0
+valkey_mode:standalone
+os:Linux 5.4.0 x86_64
+arch_bits:64
+`,
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "Valkey 8.x",
+			serverInfo: `# Server
+valkey_version:8.5.1
+valkey_mode:standalone
+os:Linux 6.2.0 x86_64
+arch_bits:64
+`,
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "Redis 7.x",
+			serverInfo: `# Server
+redis_version:7.2.3
+redis_mode:standalone
+os:Linux 5.4.0 x86_64
+arch_bits:64
+`,
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name: "Redis 6.x",
+			serverInfo: `# Server
+redis_version:6.2.14
+redis_mode:standalone
+os:Linux 5.4.0 x86_64
+arch_bits:64
+`,
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name: "Redis 8.0 (future)",
+			serverInfo: `# Server
+redis_version:8.0.0
+redis_mode:standalone
+os:Linux 5.4.0 x86_64
+arch_bits:64
+`,
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name: "Redis with extra spaces in version",
+			serverInfo: `# Server
+redis_version: 7.2.3
+redis_mode:standalone
+`,
+			want:    false,
+			wantErr: false,
+		},
+		{
+			name:       "Empty info string",
+			serverInfo: "",
+			want:       false,
+			wantErr:    true,
+		},
+		{
+			name: "No version info",
+			serverInfo: `# Server
+os:Linux 5.4.0 x86_64
+arch_bits:64
+`,
+			want:    false,
+			wantErr: true,
+		},
+		{
+			name: "Valkey with multiple lines and extra info",
+			serverInfo: `# Server
+valkey_version:8.5.1
+# Memory
+used_memory:1234567
+# Stats
+total_connections_received:100
+`,
+			want:    true,
+			wantErr: false,
+		},
+		{
+			name: "Redis 5.0 (old version)",
+			serverInfo: `# Server
+redis_version:5.0.14
+redis_mode:standalone
+`,
+			want:    false,
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := ParseServerVersion(tt.serverInfo)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("ParseServerVersion() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("ParseServerVersion() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

internal/reader/scan_standalone_reader.go

@@ -53,6 +53,7 @@ type scanStandaloneReader struct {
 	needRestoreChan chan *needRestoreItem
 	dumpClient      *client.Redis
 	subWG           sync.WaitGroup
+	isValkey        bool
 
 	stat struct {
 		Name              string `json:"name"`
@@ -206,6 +207,8 @@ func (r *scanStandaloneReader) scan() {
 func (r *scanStandaloneReader) dump() {
 	nowDbId := 0
 	r.dumpClient = client.NewRedisClient(r.ctx, r.opts.Address, r.opts.Username, r.opts.Password, r.opts.Tls, r.opts.TlsConfig, r.opts.PreferReplica)
+	r.isValkey = r.dumpClient.IsValkey()
+	log.Infof("[%s] detected server type: %s", r.stat.Name, map[bool]string{true: "Valkey", false: "Redis"}[r.isValkey])
 	// Support prefer_replica=true in both Cluster and Standalone mode
 	if r.opts.PreferReplica {
 		r.dumpClient.Do("READONLY")
@@ -300,9 +303,7 @@ func (r *scanStandaloneReader) restore() {
 				"rdb_restore_command_behavior setting may not work correctly for this key.", key, len(dump))
 			typeByte := dump[0]
 			anotherReader := strings.NewReader(dump[1 : len(dump)-10])
-			// TODO: detect if server is Valkey and pass appropriate flag
-			// For now, assume Redis format (false)
-			o := types.ParseObject(anotherReader, typeByte, key, false)
+			o := types.ParseObject(anotherReader, typeByte, key, r.isValkey)
 			cmdC := o.Rewrite()
 			for cmd := range cmdC {
 				e := entry.NewEntry()