fix(pubsub): avoid panics on Channel conflict and Ring empty subscribe

pubsub.go

@@ -37,6 +37,11 @@ type PubSub struct {
 	closed bool
 	exit   chan struct{}
 
+	// stickyErr is set when PubSub is constructed in a failed state (e.g. Ring
+	// shard lookup failure). Subsequent operations return this error instead of
+	// panicking at construction time.
+	stickyErr error
+
 	cmd *Cmd
 
 	chOnce sync.Once
@@ -72,6 +77,9 @@ func (c *PubSub) connWithLock(ctx context.Context) (*pool.Conn, error) {
 }
 
 func (c *PubSub) conn(ctx context.Context, newChannels []string) (*pool.Conn, error) {
+	if c.stickyErr != nil {
+		return nil, c.stickyErr
+	}
 	if c.closed {
 		return nil, pool.ErrClosed
 	}
@@ -575,8 +583,13 @@ func (c *PubSub) Channel(opts ...ChannelOption) <-chan *Message {
 		c.msgCh.initMsgChan()
 	})
 	if c.msgCh == nil {
-		err := fmt.Errorf("redis: Channel can't be called after ChannelWithSubscriptions")
-		panic(err)
+		// Already using ChannelWithSubscriptions — return a closed channel
+		// instead of panicking so callers can recover (issue #3761).
+		internal.Logger.Printf(c.getContext(),
+			"redis: Channel can't be called after ChannelWithSubscriptions")
+		ch := make(chan *Message)
+		close(ch)
+		return ch
 	}
 	return c.msgCh.msgCh
 }
@@ -600,8 +613,13 @@ func (c *PubSub) ChannelWithSubscriptions(opts ...ChannelOption) <-chan interfac
 		c.allCh.initAllChan()
 	})
 	if c.allCh == nil {
-		err := fmt.Errorf("redis: ChannelWithSubscriptions can't be called after Channel")
-		panic(err)
+		// Already using Channel — return a closed channel instead of panicking
+		// so callers can recover (issue #3761).
+		internal.Logger.Printf(c.getContext(),
+			"redis: ChannelWithSubscriptions can't be called after Channel")
+		ch := make(chan interface{})
+		close(ch)
+		return ch
 	}
 	return c.allCh.allCh
 }

pubsub_sticky_error_test.go

@@ -0,0 +1,51 @@
+package redis_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/redis/go-redis/v9"
+)
+
+func TestRingSubscribeEmptyChannelsNoPanic(t *testing.T) {
+	ring := redis.NewRing(&redis.RingOptions{
+		Addrs: map[string]string{"shard1": "localhost:6379"},
+	})
+	defer ring.Close()
+
+	pubsub := ring.Subscribe(context.Background())
+	if pubsub == nil {
+		t.Fatal("expected non-nil PubSub")
+	}
+	// Receive should surface sticky error, not panic.
+	_, err := pubsub.Receive(context.Background())
+	if err == nil {
+		t.Fatal("expected sticky error from empty Subscribe")
+	}
+	_ = pubsub.Close()
+}
+
+func TestPubSubChannelMutualExclusionNoPanic(t *testing.T) {
+	// Construct via a client that may not be reachable — Subscribe without
+	// channels just builds a PubSub handle.
+	client := redis.NewClient(&redis.Options{Addr: "127.0.0.1:1"})
+	defer client.Close()
+	pubsub := client.Subscribe(context.Background())
+	defer pubsub.Close()
+
+	_ = pubsub.ChannelWithSubscriptions()
+	ch := pubsub.Channel()
+	// Channel must return a closed/empty channel rather than panicking.
+	select {
+	case _, ok := <-ch:
+		if ok {
+			t.Fatal("expected closed channel from conflicting Channel() call")
+		}
+	default:
+		// non-blocking closed channel may still be receivable; try again with receive
+		_, ok := <-ch
+		if ok {
+			t.Fatal("expected closed channel")
+		}
+	}
+}

ring.go

@@ -705,43 +705,54 @@ func (c *Ring) Len() int {
 	return c.sharding.Len()
 }
 
+// failedPubSub returns a PubSub that surfaces err on every operation instead of
+// panicking at construction (issue #3761).
+func (c *Ring) failedPubSub(err error) *PubSub {
+	if err == nil {
+		err = fmt.Errorf("redis: pubsub failed")
+	}
+	pubsub := &PubSub{
+		opt:       c.opt.clientOptions(),
+		stickyErr: err,
+	}
+	pubsub.init()
+	return pubsub
+}
+
 // Subscribe subscribes the client to the specified channels.
 func (c *Ring) Subscribe(ctx context.Context, channels ...string) *PubSub {
 	if len(channels) == 0 {
-		panic("at least one channel is required")
+		return c.failedPubSub(fmt.Errorf("redis: at least one channel is required"))
 	}
 
 	shard, err := c.sharding.GetByKey(channels[0])
 	if err != nil {
-		// TODO: return PubSub with sticky error
-		panic(err)
+		return c.failedPubSub(err)
 	}
 	return shard.Client.Subscribe(ctx, channels...)
 }
 
 // PSubscribe subscribes the client to the given patterns.
 func (c *Ring) PSubscribe(ctx context.Context, channels ...string) *PubSub {
 	if len(channels) == 0 {
-		panic("at least one channel is required")
+		return c.failedPubSub(fmt.Errorf("redis: at least one channel is required"))
 	}
 
 	shard, err := c.sharding.GetByKey(channels[0])
 	if err != nil {
-		// TODO: return PubSub with sticky error
-		panic(err)
+		return c.failedPubSub(err)
 	}
 	return shard.Client.PSubscribe(ctx, channels...)
 }
 
 // SSubscribe Subscribes the client to the specified shard channels.
 func (c *Ring) SSubscribe(ctx context.Context, channels ...string) *PubSub {
 	if len(channels) == 0 {
-		panic("at least one channel is required")
+		return c.failedPubSub(fmt.Errorf("redis: at least one channel is required"))
 	}
 	shard, err := c.sharding.GetByKey(channels[0])
 	if err != nil {
-		// TODO: return PubSub with sticky error
-		panic(err)
+		return c.failedPubSub(err)
 	}
 	return shard.Client.SSubscribe(ctx, channels...)
 }