assertions for multi-node and key-routing logic

Author: mgravell

src/StackExchange.Redis/KeyNotification.cs

@@ -17,19 +17,18 @@ public static bool TryParse(in RedisChannel channel, in RedisValue value, out Ke
         // validate that it looks reasonable
         var span = channel.Span;
 
-        const int PREFIX_LEN = KeySpaceStart.Length, MIN_LEN = PREFIX_LEN + MinSuffixBytes;
-        Debug.Assert(KeyEventStart.Length == PREFIX_LEN); // prove these are the same, DEBUG only
-
-        if (span.Length >= MIN_LEN)
+        // KeySpaceStart and KeyEventStart are the same size, see KeyEventPrefix_KeySpacePrefix_Length_Matches
+        if (span.Length >= KeySpacePrefix.Length + MinSuffixBytes)
         {
-            var prefix = span.Slice(0, PREFIX_LEN);
+            // check that the prefix is valid, i.e. "__keyspace@" or "__keyevent@"
+            var prefix = span.Slice(0, KeySpacePrefix.Length);
             var hash = prefix.Hash64();
             switch (hash)
             {
-                case KeySpaceStart.Hash when KeySpaceStart.Is(hash, prefix):
-                case KeyEventStart.Hash when KeyEventStart.Is(hash, prefix):
+                case KeySpacePrefix.Hash when KeySpacePrefix.Is(hash, prefix):
+                case KeyEventPrefix.Hash when KeyEventPrefix.Is(hash, prefix):
                     // check that there is *something* non-empty after the prefix, with __: as the suffix (we don't verify *what*)
-                    if (span.Slice(PREFIX_LEN).IndexOf("__:"u8) > 0)
+                    if (span.Slice(KeySpacePrefix.Length).IndexOf("__:"u8) > 0)
                     {
                         notification = new KeyNotification(in channel, in value);
                         return true;
@@ -74,8 +73,8 @@ public int Database
         {
             // prevalidated format, so we can just skip past the prefix (except for the default value)
             if (_channel.IsNull) return -1;
-            var span = _channel.Span.Slice(11);
-            var end = span.IndexOf((byte)'_'); // expecting __:
+            var span = _channel.Span.Slice(KeySpacePrefix.Length); // also works for KeyEventPrefix
+            var end = span.IndexOf((byte)'_'); // expecting "__:foo" - we'll just stop at the underscore
             if (end <= 0) return -1;
 
             span = span.Slice(0, end);
@@ -207,39 +206,39 @@ public KeyNotificationType Type
     }
 
     /// <summary>
-    /// Indicates whether this notification originated from a keyspace notification, for example <c>__keyspace@0__:mykey</c> with payload <c>set</c>.
+    /// Indicates whether this notification originated from a keyspace notification, for example <c>__keyspace@4__:mykey</c> with payload <c>set</c>.
     /// </summary>
     public bool IsKeySpace
     {
         get
         {
             var span = _channel.Span;
-            return span.Length >= KeySpaceStart.Length + MinSuffixBytes && KeySpaceStart.Is(span.Hash64(), span.Slice(0, KeySpaceStart.Length));
+            return span.Length >= KeySpacePrefix.Length + MinSuffixBytes && KeySpacePrefix.Is(span.Hash64(), span.Slice(0, KeySpacePrefix.Length));
         }
     }
 
     /// <summary>
-    /// Indicates whether this notification originated from a keyevent notification, for example <c>__keyevent@0__:set</c> with payload <c>mykey</c>.
+    /// Indicates whether this notification originated from a keyevent notification, for example <c>__keyevent@4__:set</c> with payload <c>mykey</c>.
     /// </summary>
     public bool IsKeyEvent
     {
         get
         {
             var span = _channel.Span;
-            return span.Length >= KeyEventStart.Length + MinSuffixBytes && KeyEventStart.Is(span.Hash64(), span.Slice(0, KeyEventStart.Length));
+            return span.Length >= KeyEventPrefix.Length + MinSuffixBytes && KeyEventPrefix.Is(span.Hash64(), span.Slice(0, KeyEventPrefix.Length));
         }
     }
 }
 
 internal static partial class KeyNotificationChannels
 {
     [FastHash("__keyspace@")]
-    internal static partial class KeySpaceStart
+    internal static partial class KeySpacePrefix
     {
     }
 
     [FastHash("__keyevent@")]
-    internal static partial class KeyEventStart
+    internal static partial class KeyEventPrefix
     {
     }
 }

src/StackExchange.Redis/RedisChannel.cs

@@ -167,7 +167,7 @@ public static RedisChannel Sharded(string value) =>
         /// Create a key-notification channel for a single key in a single database.
         /// </summary>
         public static RedisChannel KeySpace(in RedisKey key, int database)
-            => BuildKeySpace(key, database, RedisChannelOptions.None);
+            => BuildKeySpace(key, database, RedisChannelOptions.KeyRouted);
 
         /// <summary>
         /// Create a key-notification channel for a pattern, optionally in a specified database.

tests/StackExchange.Redis.Tests/KeyNotificationTests.cs

@@ -409,6 +409,7 @@ public void CreateKeySpaceNotification_Valid()
         var channel = RedisChannel.KeySpace("abc", 42);
         Assert.Equal("__keyspace@42__:abc", channel.ToString());
         Assert.False(channel.IsMultiNode);
+        Assert.True(channel.IsKeyRouted);
         Assert.False(channel.IsSharded);
         Assert.False(channel.IsPattern);
     }
@@ -423,6 +424,7 @@ public void CreateKeySpaceNotificationPattern(string? pattern, int? database, st
         var channel = RedisChannel.KeySpacePattern(pattern, database);
         Assert.Equal(expected, channel.ToString());
         Assert.True(channel.IsMultiNode);
+        Assert.False(channel.IsKeyRouted);
         Assert.False(channel.IsSharded);
         Assert.True(channel.IsPattern);
     }
@@ -437,6 +439,7 @@ public void CreateKeyEventNotification(KeyNotificationType type, int? database,
         var channel = RedisChannel.KeyEvent(type, database);
         Assert.Equal(expected, channel.ToString());
         Assert.True(channel.IsMultiNode);
+        Assert.False(channel.IsKeyRouted);
         Assert.False(channel.IsSharded);
         if (isPattern)
         {
@@ -447,4 +450,47 @@ public void CreateKeyEventNotification(KeyNotificationType type, int? database,
             Assert.False(channel.IsPattern);
         }
     }
+
+    [Fact]
+    public void Cannot_KeyRoute_KeySpace_SingleKeyIsKeyRouted()
+    {
+        var channel = RedisChannel.KeySpace("abc", 42);
+        Assert.False(channel.IsMultiNode);
+        Assert.True(channel.IsKeyRouted);
+        Assert.True(channel.WithKeyRouting().IsKeyRouted); // no change, still key-routed
+    }
+
+    [Fact]
+    public void Cannot_KeyRoute_KeySpacePattern()
+    {
+        var channel = RedisChannel.KeySpacePattern("abc", 42);
+        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);
+    }
+
+    [Fact]
+    public void Cannot_KeyRoute_KeyEvent()
+    {
+        var channel = RedisChannel.KeyEvent(KeyNotificationType.Set, 42);
+        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);
+    }
+
+    [Fact]
+    public void Cannot_KeyRoute_KeyEvent_Custom()
+    {
+        var channel = RedisChannel.KeyEvent("foo"u8, 42);
+        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);
+    }
+
+    [Fact]
+    public void KeyEventPrefix_KeySpacePrefix_Length_Matches()
+    {
+        // this is a sanity check for the parsing step in KeyNotification.TryParse
+        Assert.Equal(KeyNotificationChannels.KeySpacePrefix.Length, KeyNotificationChannels.KeyEventPrefix.Length);
+    }
 }