Add support for BLPOP and BRPOP commands

Issues #249 and #250

Author: Gabriel Erzse

src/NRedisStack/CoreCommands/CoreCommandBuilder.cs

@@ -46,19 +46,25 @@ public static SerializedCommand BzmPop(double timeout, RedisKey[] keys, MinMaxMo
 
         public static SerializedCommand BzPopMin(RedisKey[] keys, double timeout)
         {
-            if (keys.Length == 0)
-            {
-                throw new ArgumentException("At least one key must be provided.");
-            }
+            return BlockingCommandWithKeysAndTimeout(RedisCoreCommands.BZPOPMIN, keys, timeout);
+        }
 
-            List<object> args = new List<object>();
-            args.AddRange(keys.Cast<object>());
-            args.Add(timeout);
+        public static SerializedCommand BzPopMax(RedisKey[] keys, double timeout)
+        {
+            return BlockingCommandWithKeysAndTimeout(RedisCoreCommands.BZPOPMAX, keys, timeout);
+        }
+
+        public static SerializedCommand BlPop(RedisKey[] keys, double timeout)
+        {
+            return BlockingCommandWithKeysAndTimeout(RedisCoreCommands.BLPOP, keys, timeout);
+        }
 
-            return new SerializedCommand(RedisCoreCommands.BZPOPMIN, args);
+        public static SerializedCommand BrPop(RedisKey[] keys, double timeout)
+        {
+            return BlockingCommandWithKeysAndTimeout(RedisCoreCommands.BRPOP, keys, timeout);
         }
 
-        public static SerializedCommand BzPopMax(RedisKey[] keys, double timeout)
+        private static SerializedCommand BlockingCommandWithKeysAndTimeout(String command, RedisKey[] keys, double timeout)
         {
             if (keys.Length == 0)
             {
@@ -69,7 +75,7 @@ public static SerializedCommand BzPopMax(RedisKey[] keys, double timeout)
             args.AddRange(keys.Cast<object>());
             args.Add(timeout);
 
-            return new SerializedCommand(RedisCoreCommands.BZPOPMAX, args);
+            return new SerializedCommand(command, args);
         }
     }
 }

src/NRedisStack/CoreCommands/CoreCommands.cs

@@ -175,5 +175,101 @@ public static bool ClientSetInfo(this IDatabase db, SetInfoAttr attr, string val
         {
             return BzPopMax(db, new[] { key }, timeout);
         }
+
+        /// <summary>
+        /// The BLPOP command.
+        /// <p/>
+        /// Removes and returns an entry from the head (left side) of the first non-empty list in <paramref name="keys"/>.
+        /// If none of the lists contain elements, the call blocks on the server until elements
+        /// become available, or the given <paramref name="timeout"/> expires. A <paramref name="timeout"/> of <c>0</c>
+        /// means to wait indefinitely server-side. Returns <c>null</c> if the server timeout expires.
+        /// <p/>
+        /// When using this, pay attention to the timeout configured in the client, on the
+        /// <see cref="ConnectionMultiplexer"/>, which by default can be too small:
+        /// <code>
+        /// ConfigurationOptions configurationOptions = new ConfigurationOptions();
+        /// configurationOptions.SyncTimeout = 120000; // set a meaningful value here
+        /// configurationOptions.EndPoints.Add("localhost");
+        /// ConnectionMultiplexer redis = ConnectionMultiplexer.Connect(configurationOptions);
+        /// </code>
+        /// If the connection multiplexer timeout expires in the client, a <c>StackExchange.Redis.RedisTimeoutException</c>
+        /// is thrown.
+        /// <p/>
+        /// This is an extension method added to the <see cref="IDatabase"/> class, for convenience.
+        /// </summary>
+        /// <param name="db">The <see cref="IDatabase"/> class where this extension method is applied.</param>
+        /// <param name="keys">The keys to check.</param>
+        /// <param name="timeout">Server-side timeout for the wait. A value of <c>0</c> means to wait indefinitely.</param>
+        /// <returns>A value, together with the key it was popped from, or <c>null</c> if the server timeout
+        /// expires.</returns>
+        /// <remarks><seealso href="https://redis.io/commands/blpop"/></remarks>
+        public static Tuple<RedisKey, RedisValue>? BlPop(this IDatabase db, RedisKey[] keys, double timeout)
+        {
+            var command = CoreCommandBuilder.BlPop(keys, timeout);
+            return db.Execute(command).ToListPopResult();
+        }
+
+        /// <summary>
+        /// Syntactic sugar for <see cref="BlPop(StackExchange.Redis.IDatabase,StackExchange.Redis.RedisKey[],double)"/>,
+        /// where only one key is used.
+        /// </summary>
+        /// <param name="db">The <see cref="IDatabase"/> class where this extension method is applied.</param>
+        /// <param name="key">The key to check.</param>
+        /// <param name="timeout">Server-side timeout for the wait. A value of <c>0</c> means to wait indefinitely.</param>
+        /// <returns>A value, together with the key it was popped from, or <c>null</c> if the server timeout
+        /// expires.</returns>
+        /// <remarks><seealso href="https://redis.io/commands/blpop"/></remarks>
+        public static Tuple<RedisKey, RedisValue>? BlPop(this IDatabase db, RedisKey key, double timeout)
+        {
+            return BlPop(db, new[] { key }, timeout);
+        }
+
+        /// <summary>
+        /// The BRPOP command.
+        /// <p/>
+        /// Removes and returns an entry from the tail (right side) of the first non-empty list in <paramref name="keys"/>.
+        /// If none of the lists contain elements, the call blocks on the server until elements
+        /// become available, or the given <paramref name="timeout"/> expires. A <paramref name="timeout"/> of <c>0</c>
+        /// means to wait indefinitely server-side. Returns <c>null</c> if the server timeout expires.
+        /// <p/>
+        /// When using this, pay attention to the timeout configured in the client, on the
+        /// <see cref="ConnectionMultiplexer"/>, which by default can be too small:
+        /// <code>
+        /// ConfigurationOptions configurationOptions = new ConfigurationOptions();
+        /// configurationOptions.SyncTimeout = 120000; // set a meaningful value here
+        /// configurationOptions.EndPoints.Add("localhost");
+        /// ConnectionMultiplexer redis = ConnectionMultiplexer.Connect(configurationOptions);
+        /// </code>
+        /// If the connection multiplexer timeout expires in the client, a <c>StackExchange.Redis.RedisTimeoutException</c>
+        /// is thrown.
+        /// <p/>
+        /// This is an extension method added to the <see cref="IDatabase"/> class, for convenience.
+        /// </summary>
+        /// <param name="db">The <see cref="IDatabase"/> class where this extension method is applied.</param>
+        /// <param name="keys">The keys to check.</param>
+        /// <param name="timeout">Server-side timeout for the wait. A value of <c>0</c> means to wait indefinitely.</param>
+        /// <returns>A value, together with the key it was popped from, or <c>null</c> if the server timeout
+        /// expires.</returns>
+        /// <remarks><seealso href="https://redis.io/commands/brpop"/></remarks>
+        public static Tuple<RedisKey, RedisValue>? BrPop(this IDatabase db, RedisKey[] keys, double timeout)
+        {
+            var command = CoreCommandBuilder.BrPop(keys, timeout);
+            return db.Execute(command).ToListPopResult();
+        }
+
+        /// <summary>
+        /// Syntactic sugar for <see cref="BlPop(StackExchange.Redis.IDatabase,StackExchange.Redis.RedisKey[],double)"/>,
+        /// where only one key is used.
+        /// </summary>
+        /// <param name="db">The <see cref="IDatabase"/> class where this extension method is applied.</param>
+        /// <param name="key">The key to check.</param>
+        /// <param name="timeout">Server-side timeout for the wait. A value of <c>0</c> means to wait indefinitely.</param>
+        /// <returns>A value, together with the key it was popped from, or <c>null</c> if the server timeout
+        /// expires.</returns>
+        /// <remarks><seealso href="https://redis.io/commands/brpop"/></remarks>
+        public static Tuple<RedisKey, RedisValue>? BrPop(this IDatabase db, RedisKey key, double timeout)
+        {
+            return BrPop(db, new[] { key }, timeout);
+        }
     }
 }

src/NRedisStack/CoreCommands/Literals/Commands.cs

@@ -5,6 +5,8 @@ namespace NRedisStack.Core.Literals
     /// </summary>
     internal static class RedisCoreCommands
     {
+        public const string BLPOP = "BLPOP";
+        public const string BRPOP = "BRPOP";
         public const string BZMPOP = "BZMPOP";
         public const string BZPOPMAX = "BZPOPMAX";
         public const string BZPOPMIN = "BZPOPMIN";

src/NRedisStack/ResponseParser.cs

@@ -766,5 +766,19 @@ public static Dictionary<string, RedisResult>[] ToDictionarys(this RedisResult r
 
             return new Tuple<RedisKey, List<RedisValueWithScore>>(resultKey, valuesWithScores);
         }
+
+        public static Tuple<RedisKey, RedisValue>? ToListPopResult(this RedisResult result)
+        {
+            if (result.IsNull)
+            {
+                return null;
+            }
+
+            var resultArray = (RedisResult[])result!;
+            var resultKey = resultArray[0].ToRedisKey();
+            var value = resultArray[1].ToRedisValue();
+
+            return new Tuple<RedisKey, RedisValue>(resultKey, value);
+        }
     }
 }

tests/NRedisStack.Tests/Core Commands/CoreTests.cs

@@ -406,4 +406,118 @@ public void TestBzPopMaxMultipleSets()
         Assert.Equal("set-one", result!.Item1);
         Assert.Equal("b", result.Item2.Value.ToString());
     }
+
+    [SkipIfRedis(Is.OSSCluster, Comparison.LessThan, "5.0.0")]
+    public void TestBlPop()
+    {
+        var redis = ConnectionMultiplexer.Connect("localhost");
+
+        var db = redis.GetDatabase(null);
+        db.Execute("FLUSHALL");
+
+        db.ListRightPush("my-list", "a");
+        db.ListRightPush("my-list", "b");
+
+        var result = db.BlPop("my-list", 0);
+
+        Assert.NotNull(result);
+        Assert.Equal("my-list", result!.Item1);
+        Assert.Equal("a", result.Item2.ToString());
+    }
+
+    [SkipIfRedis(Is.OSSCluster, Comparison.LessThan, "5.0.0")]
+    public void TestBlPopNull()
+    {
+        var redis = ConnectionMultiplexer.Connect("localhost");
+
+        var db = redis.GetDatabase(null);
+        db.Execute("FLUSHALL");
+
+        // Nothing in the set, and a short server timeout, which yields null.
+        var result = db.BlPop("my-set", 0.5);
+
+        Assert.Null(result);
+    }
+
+    [SkipIfRedis(Is.OSSCluster, Comparison.LessThan, "5.0.0")]
+    public void TestBlPopMultipleLists()
+    {
+        var redis = ConnectionMultiplexer.Connect("localhost");
+
+        var db = redis.GetDatabase(null);
+        db.Execute("FLUSHALL");
+
+        db.ListRightPush("list-one", "a");
+        db.ListRightPush("list-one", "b");
+        db.ListRightPush("list-two", "e");
+
+        var result = db.BlPop(new[] { new RedisKey("list-two"), new RedisKey("list-one") }, 0);
+
+        Assert.NotNull(result);
+        Assert.Equal("list-two", result!.Item1);
+        Assert.Equal("e", result.Item2.ToString());
+
+        result = db.BlPop(new[] { new RedisKey("list-two"), new RedisKey("list-one") }, 0);
+
+        Assert.NotNull(result);
+        Assert.Equal("list-one", result!.Item1);
+        Assert.Equal("a", result.Item2.ToString());
+    }
+
+    [SkipIfRedis(Is.OSSCluster, Comparison.LessThan, "5.0.0")]
+    public void TestBrPop()
+    {
+        var redis = ConnectionMultiplexer.Connect("localhost");
+
+        var db = redis.GetDatabase(null);
+        db.Execute("FLUSHALL");
+
+        db.ListRightPush("my-list", "a");
+        db.ListRightPush("my-list", "b");
+
+        var result = db.BrPop("my-list", 0);
+
+        Assert.NotNull(result);
+        Assert.Equal("my-list", result!.Item1);
+        Assert.Equal("b", result.Item2.ToString());
+    }
+
+    [SkipIfRedis(Is.OSSCluster, Comparison.LessThan, "5.0.0")]
+    public void TestBrPopNull()
+    {
+        var redis = ConnectionMultiplexer.Connect("localhost");
+
+        var db = redis.GetDatabase(null);
+        db.Execute("FLUSHALL");
+
+        // Nothing in the set, and a short server timeout, which yields null.
+        var result = db.BrPop("my-set", 0.5);
+
+        Assert.Null(result);
+    }
+
+    [SkipIfRedis(Is.OSSCluster, Comparison.LessThan, "5.0.0")]
+    public void TestBrPopMultipleLists()
+    {
+        var redis = ConnectionMultiplexer.Connect("localhost");
+
+        var db = redis.GetDatabase(null);
+        db.Execute("FLUSHALL");
+
+        db.ListRightPush("list-one", "a");
+        db.ListRightPush("list-one", "b");
+        db.ListRightPush("list-two", "e");
+
+        var result = db.BrPop(new[] { new RedisKey("list-two"), new RedisKey("list-one") }, 0);
+
+        Assert.NotNull(result);
+        Assert.Equal("list-two", result!.Item1);
+        Assert.Equal("e", result.Item2.ToString());
+
+        result = db.BrPop(new[] { new RedisKey("list-two"), new RedisKey("list-one") }, 0);
+
+        Assert.NotNull(result);
+        Assert.Equal("list-one", result!.Item1);
+        Assert.Equal("b", result.Item2.ToString());
+    }
 }