feat: Add Mode() Method to rueidis.Client for Detecting Client Mode

client.go

@@ -189,6 +189,10 @@ func (c *singleClient) Nodes() map[string]Client {
 	return map[string]Client{c.conn.Addr(): c}
 }
 
+func (c *singleClient) Mode() ClientMode {
+	return ClientModeStandalone
+}
+
 func (c *singleClient) Close() {
 	atomic.StoreUint32(&c.stop, 1)
 	c.conn.Close()

client_test.go

@@ -262,6 +262,12 @@ func TestSingleClient(t *testing.T) {
 		}
 	})
 
+	t.Run("Mode", func(t *testing.T) {
+		if v := client.Mode(); v != ClientModeStandalone {
+			t.Fatalf("unexpected mode %v", v)
+		}
+	})
+
 	t.Run("Delegate Do", func(t *testing.T) {
 		c := client.B().Get().Key("Do").Build()
 		m.DoFn = func(cmd Completed) RedisResult {

cluster.go

@@ -1203,6 +1203,10 @@ func (c *clusterClient) Nodes() map[string]Client {
 	return _nodes
 }
 
+func (c *clusterClient) Mode() ClientMode {
+	return ClientModeCluster
+}
+
 func (c *clusterClient) Close() {
 	if atomic.CompareAndSwapUint32(&c.stop, 0, 1) {
 		close(c.stopCh)

cluster_test.go

@@ -1589,6 +1589,12 @@ func TestClusterClient(t *testing.T) {
 		}
 	})
 
+	t.Run("Mode", func(t *testing.T) {
+		if client.Mode() != ClientModeCluster {
+			t.Fatalf("unexpected mode %v", client.Mode())
+		}
+	})
+
 	t.Run("Delegate Do with no slot", func(t *testing.T) {
 		c := client.B().Info().Build()
 		if v, err := client.Do(context.Background(), c).ToString(); err != nil || v != "Info" {

lua_test.go

@@ -204,6 +204,7 @@ type client struct {
 	DedicatedFn    func(fn func(DedicatedClient) error) (err error)
 	DedicateFn     func() (DedicatedClient, func())
 	CloseFn        func()
+	ModeFn         func() ClientMode
 }
 
 func (c *client) Receive(ctx context.Context, subscribe Completed, fn func(msg PubSubMessage)) error {
@@ -271,6 +272,10 @@ func (c *client) Nodes() map[string]Client {
 	return map[string]Client{"addr": c}
 }
 
+func (c *client) Mode() ClientMode {
+	return c.ModeFn()
+}
+
 func (c *client) Close() {
 	if c.CloseFn != nil {
 		c.CloseFn()

mock/client.go

@@ -60,6 +60,10 @@ func (m *Client) B() rueidis.Builder {
 	return cmds.NewBuilder(m.slot)
 }
 
+func (m *Client) Mode() rueidis.ClientMode {
+	return rueidis.ClientModeStandalone
+}
+
 // Close mocks base method.
 func (m *Client) Close() {
 	m.ctrl.T.Helper()

rueidis.go

@@ -35,6 +35,10 @@ const (
 	DefaultWriteBuffer = 1 << 19
 	// MaxPipelineMultiplex is the maximum meaningful value for ClientOption.PipelineMultiplex
 	MaxPipelineMultiplex = 8
+	// https://github.com/valkey-io/valkey/blob/1a34a4ff7f101bb6b17a0b5e9aa3bf7d6bd29f68/src/networking.c#L4118-L4124
+	ClientModeCluster    ClientMode = "cluster"
+	ClientModeSentinel   ClientMode = "sentinel"
+	ClientModeStandalone ClientMode = "standalone"
 )
 
 var (
@@ -258,6 +262,8 @@ type ReplicaInfo struct {
 	AZ   string
 }
 
+type ClientMode string
+
 // Client is the redis client interface for both single redis instance and redis cluster. It should be created from the NewClient()
 type Client interface {
 	CoreClient
@@ -307,6 +313,11 @@ type Client interface {
 	// Nodes returns each redis node this client known as rueidis.Client. This is useful if you want to
 	// send commands to some specific redis nodes in the cluster.
 	Nodes() map[string]Client
+	// Mode returns the current mode of the client, which indicates whether the client is operating
+	// in standalone, sentinel, or cluster mode.
+	// This can be useful for determining the type of Redis deployment the client is connected to
+	// and for making decisions based on the deployment type.
+	Mode() ClientMode
 }
 
 // DedicatedClient is obtained from Client.Dedicated() and it will be bound to single redis connection and

rueidiscompat/tx.go

@@ -107,6 +107,10 @@ func (p *txproxy) Nodes() map[string]rueidis.Client {
 	panic("not implemented")
 }
 
+func (p *txproxy) Mode() rueidis.ClientMode {
+	panic("not implemented")
+}
+
 type Tx interface {
 	CoreCmdable
 	Watch(ctx context.Context, keys ...string) *StatusCmd

rueidishook/hook.go

@@ -82,6 +82,10 @@ func (c *hookclient) Nodes() map[string]rueidis.Client {
 	return nodes
 }
 
+func (c *hookclient) Mode() rueidis.ClientMode {
+	return c.client.Mode()
+}
+
 func (c *hookclient) Close() {
 	c.client.Close()
 }
@@ -150,6 +154,10 @@ func (e *extended) Nodes() map[string]rueidis.Client {
 	panic("Nodes() is not allowed with rueidis.DedicatedClient")
 }
 
+func (e *extended) Mode() rueidis.ClientMode {
+	panic("Mode() is not allowed with rueidis.DedicatedClient")
+}
+
 type result struct {
 	err error
 	val rueidis.RedisMessage

rueidisotel/trace.go

@@ -203,6 +203,10 @@ func (o *otelclient) Nodes() map[string]rueidis.Client {
 	return nodes
 }
 
+func (o *otelclient) Mode() rueidis.ClientMode {
+	return o.client.Mode()
+}
+
 func (o *otelclient) Close() {
 	o.client.Close()
 }

sentinel.go

@@ -218,6 +218,10 @@ func (c *sentinelClient) Nodes() map[string]Client {
 	return map[string]Client{conn.Addr(): newSingleClientWithConn(conn, c.cmd, c.retry, disableCache, c.retryHandler)}
 }
 
+func (c *sentinelClient) Mode() ClientMode {
+	return ClientModeSentinel
+}
+
 func (c *sentinelClient) Close() {
 	atomic.StoreUint32(&c.stop, 1)
 	c.mu.Lock()

sentinel_test.go

@@ -782,6 +782,12 @@ func TestSentinelClientDelegate(t *testing.T) {
 		}
 	})
 
+	t.Run("Mode", func(t *testing.T) {
+		if mode := client.Mode(); mode != ClientModeSentinel {
+			t.Fatalf("unexpected mode %v", mode)
+		}
+	})
+
 	t.Run("Delegate Do", func(t *testing.T) {
 		c := client.B().Get().Key("Do").Build()
 		m.DoFn = func(cmd Completed) RedisResult {