prevent publish on multi-node channels

Author: mgravell

src/StackExchange.Redis/RedisChannel.cs

@@ -29,7 +29,17 @@ internal enum RedisChannelOptions
         private const RedisChannelOptions EqualityMask =
             ~(RedisChannelOptions.KeyRouted | RedisChannelOptions.MultiNode);
 
-        internal RedisCommand PublishCommand => IsSharded ? RedisCommand.SPUBLISH : RedisCommand.PUBLISH;
+        internal RedisCommand GetPublishCommand()
+        {
+            return (Options & (RedisChannelOptions.Sharded | RedisChannelOptions.MultiNode)) switch
+            {
+                RedisChannelOptions.None => RedisCommand.PUBLISH,
+                RedisChannelOptions.Sharded => RedisCommand.SPUBLISH,
+                _ => ThrowKeyRouted(),
+            };
+
+            static RedisCommand ThrowKeyRouted() => throw new InvalidOperationException("Publishing is not supported for multi-node channels");
+        }
 
         /// <summary>
         /// Should we use cluster routing for this channel? This applies *either* to sharded (<c>SPUBLISH</c>) scenarios,

src/StackExchange.Redis/RedisDatabase.cs

@@ -1901,15 +1901,15 @@ public Task<LCSMatchResult> StringLongestCommonSubsequenceWithMatchesAsync(Redis
         public long Publish(RedisChannel channel, RedisValue message, CommandFlags flags = CommandFlags.None)
         {
             if (channel.IsNullOrEmpty) throw new ArgumentNullException(nameof(channel));
-            var msg = Message.Create(-1, flags, channel.PublishCommand, channel, message);
+            var msg = Message.Create(-1, flags, channel.GetPublishCommand(), channel, message);
             // if we're actively subscribed: send via that connection (otherwise, follow normal rules)
             return ExecuteSync(msg, ResultProcessor.Int64, server: multiplexer.GetSubscribedServer(channel));
         }
 
         public Task<long> PublishAsync(RedisChannel channel, RedisValue message, CommandFlags flags = CommandFlags.None)
         {
             if (channel.IsNullOrEmpty) throw new ArgumentNullException(nameof(channel));
-            var msg = Message.Create(-1, flags, channel.PublishCommand, channel, message);
+            var msg = Message.Create(-1, flags, channel.GetPublishCommand(), channel, message);
             // if we're actively subscribed: send via that connection (otherwise, follow normal rules)
             return ExecuteAsync(msg, ResultProcessor.Int64, server: multiplexer.GetSubscribedServer(channel));
         }

src/StackExchange.Redis/RedisSubscriber.cs

@@ -393,15 +393,15 @@ private static void ThrowIfNull(in RedisChannel channel)
         public long Publish(RedisChannel channel, RedisValue message, CommandFlags flags = CommandFlags.None)
         {
             ThrowIfNull(channel);
-            var msg = Message.Create(-1, flags, channel.PublishCommand, channel, message);
+            var msg = Message.Create(-1, flags, channel.GetPublishCommand(), channel, message);
             // if we're actively subscribed: send via that connection (otherwise, follow normal rules)
             return ExecuteSync(msg, ResultProcessor.Int64, server: multiplexer.GetSubscribedServer(channel));
         }
 
         public Task<long> PublishAsync(RedisChannel channel, RedisValue message, CommandFlags flags = CommandFlags.None)
         {
             ThrowIfNull(channel);
-            var msg = Message.Create(-1, flags, channel.PublishCommand, channel, message);
+            var msg = Message.Create(-1, flags, channel.GetPublishCommand(), channel, message);
             // if we're actively subscribed: send via that connection (otherwise, follow normal rules)
             return ExecuteAsync(msg, ResultProcessor.Int64, server: multiplexer.GetSubscribedServer(channel));
         }

tests/StackExchange.Redis.Tests/KeyNotificationTests.cs

@@ -458,6 +458,7 @@ public void Cannot_KeyRoute_KeySpace_SingleKeyIsKeyRouted()
         Assert.False(channel.IsMultiNode);
         Assert.True(channel.IsKeyRouted);
         Assert.True(channel.WithKeyRouting().IsKeyRouted); // no change, still key-routed
+        Assert.Equal(RedisCommand.PUBLISH, channel.GetPublishCommand());
     }
 
     [Fact]
@@ -467,6 +468,7 @@ public void Cannot_KeyRoute_KeySpacePattern()
         Assert.True(channel.IsMultiNode);
         Assert.False(channel.IsKeyRouted);
         Assert.StartsWith("Key routing is not supported for multi-node channels", Assert.Throws<InvalidOperationException>(() => channel.WithKeyRouting()).Message);
+        Assert.StartsWith("Publishing is not supported for multi-node channels", Assert.Throws<InvalidOperationException>(() => channel.GetPublishCommand()).Message);
     }
 
     [Fact]
@@ -476,6 +478,7 @@ public void Cannot_KeyRoute_KeyEvent()
         Assert.True(channel.IsMultiNode);
         Assert.False(channel.IsKeyRouted);
         Assert.StartsWith("Key routing is not supported for multi-node channels", Assert.Throws<InvalidOperationException>(() => channel.WithKeyRouting()).Message);
+        Assert.StartsWith("Publishing is not supported for multi-node channels", Assert.Throws<InvalidOperationException>(() => channel.GetPublishCommand()).Message);
     }
 
     [Fact]
@@ -485,6 +488,7 @@ public void Cannot_KeyRoute_KeyEvent_Custom()
         Assert.True(channel.IsMultiNode);
         Assert.False(channel.IsKeyRouted);
         Assert.StartsWith("Key routing is not supported for multi-node channels", Assert.Throws<InvalidOperationException>(() => channel.WithKeyRouting()).Message);
+        Assert.StartsWith("Publishing is not supported for multi-node channels", Assert.Throws<InvalidOperationException>(() => channel.GetPublishCommand()).Message);
     }
 
     [Fact]