Add support for the BLMPOP command

Issue #248

Author: Gabriel Erzse

src/NRedisStack/CoreCommands/CoreCommandBuilder.cs

@@ -54,6 +54,29 @@ public static SerializedCommand BzPopMax(RedisKey[] keys, double timeout)
             return BlockingCommandWithKeysAndTimeout(RedisCoreCommands.BZPOPMAX, keys, timeout);
         }
 
+        public static SerializedCommand BlmPop(double timeout, RedisKey[] keys, ListSide listSide, long? count)
+        {
+            if (keys.Length == 0)
+            {
+                throw new ArgumentException("At least one key must be provided.");
+            }
+
+            List<object> args = new List<object>();
+
+            args.Add(timeout);
+            args.Add(keys.Length);
+            args.AddRange(keys.Cast<object>());
+            args.Add(listSide == ListSide.Left ? CoreArgs.LEFT : CoreArgs.RIGHT);
+
+            if (count != null)
+            {
+                args.Add(CoreArgs.COUNT);
+                args.Add(count);
+            }
+
+            return new SerializedCommand(RedisCoreCommands.BLMPOP, args);
+        }
+
         public static SerializedCommand BlPop(RedisKey[] keys, double timeout)
         {
             return BlockingCommandWithKeysAndTimeout(RedisCoreCommands.BLPOP, keys, timeout);

src/NRedisStack/CoreCommands/CoreCommands.cs

@@ -176,6 +176,61 @@ public static bool ClientSetInfo(this IDatabase db, SetInfoAttr attr, string val
             return BzPopMax(db, new[] { key }, timeout);
         }
 
+        /// <summary>
+        /// The BLMPOP command.
+        /// <p/>
+        /// Removes and returns up to <paramref name="count"/> entries from 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="timeout">Server-side timeout for the wait. A value of <c>0</c> means to wait indefinitely.</param>
+        /// <param name="keys">The keys to check.</param>
+        /// <param name="listSide">Specify from which end of the list to pop values: left or right.</param>
+        /// <param name="count">The maximum number of records to pop. If set to <c>null</c> then the server default
+        /// will be used.</param>
+        /// <returns>A collection of values, together with the key they were popped from, or <c>null</c> if the
+        /// server timeout expires.</returns>
+        /// <remarks><seealso href="https://redis.io/commands/blmpop"/></remarks>
+        public static Tuple<RedisKey, List<RedisValue>>? BlmPop(this IDatabase db, double timeout, RedisKey[] keys, ListSide listSide, long? count = null)
+        {
+            var command = CoreCommandBuilder.BlmPop(timeout, keys, listSide, count);
+            return db.Execute(command).ToListPopResults();
+        }
+
+        /// <summary>
+        /// Syntactic sugar for
+        /// <see cref="BlmPop(StackExchange.Redis.IDatabase,double,StackExchange.Redis.RedisKey[],StackExchange.Redis.ListSide,System.Nullable{long})"/>,
+        /// where only one key is used.
+        /// </summary>
+        /// <param name="db">The <see cref="IDatabase"/> class where this extension method is applied.</param>
+        /// <param name="timeout">Server-side timeout for the wait. A value of <c>0</c> means to wait indefinitely.</param>
+        /// <param name="key">The key to check.</param>
+        /// <param name="listSide">Specify from which end of the list to pop values: left or right.</param>
+        /// <param name="count">The maximum number of records to pop. If set to <c>null</c> then the server default
+        /// will be used.</param>
+        /// <returns>A collection of values, together with the key they were popped from, or <c>null</c> if the
+        /// server timeout expires.</returns>
+        /// <remarks><seealso href="https://redis.io/commands/blmpop"/></remarks>
+        public static Tuple<RedisKey, List<RedisValue>>? BlmPop(this IDatabase db, double timeout, RedisKey key, ListSide listSide, long? count = null)
+        {
+            return BlmPop(db, timeout, new[] { key }, listSide, count);
+        }
+
         /// <summary>
         /// The BLPOP command.
         /// <p/>

src/NRedisStack/CoreCommands/Literals/CommandArgs.cs

@@ -3,9 +3,11 @@ namespace NRedisStack.Core.Literals
     internal static class CoreArgs
     {
         public const string COUNT = "COUNT";
-        public const string lib_name = "LIB-NAME";
-        public const string lib_ver = "LIB-VER";
+        public const string LEFT = "LEFT";
         public const string MAX = "MAX";
         public const string MIN = "MIN";
+        public const string RIGHT = "RIGHT";
+        public const string lib_name = "LIB-NAME";
+        public const string lib_ver = "LIB-VER";
     }
 }

src/NRedisStack/CoreCommands/Literals/Commands.cs

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

src/NRedisStack/ResponseParser.cs

@@ -780,5 +780,27 @@ public static Dictionary<string, RedisResult>[] ToDictionarys(this RedisResult r
 
             return new Tuple<RedisKey, RedisValue>(resultKey, value);
         }
+
+        public static Tuple<RedisKey, List<RedisValue>>? ToListPopResults(this RedisResult result)
+        {
+            if (result.IsNull)
+            {
+                return null;
+            }
+
+            var resultArray = (RedisResult[])result!;
+            var resultKey = resultArray[0].ToRedisKey();
+            var resultSetItems = resultArray[1].ToArray();
+
+            List<RedisValue> values = new List<RedisValue>();
+
+            foreach (var resultSetItem in resultSetItems)
+            {
+                var value = (RedisValue)resultSetItem!;
+                values.Add(value);
+            }
+
+            return new Tuple<RedisKey, List<RedisValue>>(resultKey, values);
+        }
     }
 }

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

@@ -153,7 +153,7 @@ public void TestBzmPop()
         db.SortedSetAdd(sortedSetKey, "d", 9.4);
         db.SortedSetAdd(sortedSetKey, "e", 7.76);
 
-        // Pop two items with default order, which means it will pop the minimum values.
+        // Pop two items with Min modifier, which means it will pop the minimum values.
         var resultWithDefaultOrder = db.BzmPop(0, sortedSetKey, MinMaxModifier.Min, 2);
 
         Assert.NotNull(resultWithDefaultOrder);
@@ -162,7 +162,7 @@ public void TestBzmPop()
         Assert.Equal("a", resultWithDefaultOrder.Item2[0].Value.ToString());
         Assert.Equal("c", resultWithDefaultOrder.Item2[1].Value.ToString());
 
-        // Pop one more item, with descending order, which means it will pop the maximum value.
+        // Pop one more item, with Max modifier, which means it will pop the maximum value.
         var resultWithDescendingOrder = db.BzmPop(0, sortedSetKey, MinMaxModifier.Max, 1);
 
         Assert.NotNull(resultWithDescendingOrder);
@@ -252,7 +252,6 @@ public void TestBzmPopNoKeysProvided()
         var db = redis.GetDatabase(null);
         db.Execute("FLUSHALL");
 
-        // Server would wait forever, but the multiplexer times out in 1 second.
         Assert.Throws<ArgumentException>(() => db.BzmPop(0, Array.Empty<RedisKey>(), MinMaxModifier.Min));
     }
 
@@ -270,15 +269,15 @@ public void TestBzmPopWithOrderEnum()
         db.SortedSetAdd(sortedSetKey, "b", 5.1);
         db.SortedSetAdd(sortedSetKey, "c", 3.7);
 
-        // Pop two items with default order, which means it will pop the minimum values.
+        // Pop two items with Ascending order, which means it will pop the minimum values.
         var resultWithDefaultOrder = db.BzmPop(0, sortedSetKey, Order.Ascending.ToMinMax());
 
         Assert.NotNull(resultWithDefaultOrder);
         Assert.Equal(sortedSetKey, resultWithDefaultOrder!.Item1);
         Assert.Single(resultWithDefaultOrder.Item2);
         Assert.Equal("a", resultWithDefaultOrder.Item2[0].Value.ToString());
 
-        // Pop one more item, with descending order, which means it will pop the maximum value.
+        // Pop one more item, with Descending order, which means it will pop the maximum value.
         var resultWithDescendingOrder = db.BzmPop(0, sortedSetKey, Order.Descending.ToMinMax());
 
         Assert.NotNull(resultWithDescendingOrder);
@@ -406,6 +405,106 @@ public void TestBzPopMaxMultipleSets()
         Assert.Equal("set-one", result!.Item1);
         Assert.Equal("b", result.Item2.Value.ToString());
     }
+    [SkipIfRedis(Is.OSSCluster, Comparison.LessThan, "7.0.0")]
+    public void TestBlmPop()
+    {
+        var redis = ConnectionMultiplexer.Connect("localhost");
+
+        var db = redis.GetDatabase(null);
+        db.Execute("FLUSHALL");
+
+        db.ListRightPush("my-list", "a");
+        db.ListRightPush("my-list", "b");
+        db.ListRightPush("my-list", "c");
+        db.ListRightPush("my-list", "d");
+        db.ListRightPush("my-list", "e");
+
+        // Pop two items from the left side.
+        var resultWithDefaultOrder = db.BlmPop(0, "my-list", ListSide.Left, 2);
+
+        Assert.NotNull(resultWithDefaultOrder);
+        Assert.Equal("my-list", resultWithDefaultOrder!.Item1);
+        Assert.Equal(2, resultWithDefaultOrder.Item2.Count);
+        Assert.Equal("a", resultWithDefaultOrder.Item2[0].ToString());
+        Assert.Equal("b", resultWithDefaultOrder.Item2[1].ToString());
+
+        // Pop one more item, from the right side.
+        var resultWithDescendingOrder = db.BlmPop(0, "my-list", ListSide.Right, 1);
+
+        Assert.NotNull(resultWithDescendingOrder);
+        Assert.Equal("my-list", resultWithDescendingOrder!.Item1);
+        Assert.Single(resultWithDescendingOrder.Item2);
+        Assert.Equal("e", resultWithDescendingOrder.Item2[0].ToString());
+    }
+
+    [SkipIfRedis(Is.OSSCluster, Comparison.LessThan, "7.0.0")]
+    public void TestBlmPopNull()
+    {
+        var redis = ConnectionMultiplexer.Connect("localhost");
+
+        var db = redis.GetDatabase(null);
+        db.Execute("FLUSHALL");
+
+        // Nothing in the list, and a short server timeout, which yields null.
+        var result = db.BlmPop(0.5, "my-list", ListSide.Left);
+
+        Assert.Null(result);
+    }
+
+    [SkipIfRedis(Is.OSSCluster, Comparison.LessThan, "7.0.0")]
+    public void TestBlmPopMultipleLists()
+    {
+        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-one", "c");
+        db.ListRightPush("list-two", "d");
+        db.ListRightPush("list-two", "e");
+
+        var result = db.BlmPop(0, "list-two", ListSide.Right);
+
+        Assert.NotNull(result);
+        Assert.Equal("list-two", result!.Item1);
+        Assert.Single(result.Item2);
+        Assert.Equal("e", result.Item2[0].ToString());
+
+        result = db.BlmPop(0, new[] { new RedisKey("list-two"), new RedisKey("list-one") }, ListSide.Left);
+
+        Assert.NotNull(result);
+        Assert.Equal("list-two", result!.Item1);
+        Assert.Single(result.Item2);
+        Assert.Equal("d", result.Item2[0].ToString());
+
+        result = db.BlmPop(0, new[] { new RedisKey("list-two"), new RedisKey("list-one") }, ListSide.Right);
+
+        Assert.NotNull(result);
+        Assert.Equal("list-one", result!.Item1);
+        Assert.Single(result.Item2);
+        Assert.Equal("c", result.Item2[0].ToString());
+
+        result = db.BlmPop(0, "list-one", ListSide.Left, count: 2);
+
+        Assert.NotNull(result);
+        Assert.Equal("list-one", result!.Item1);
+        Assert.Equal(2, result.Item2.Count);
+        Assert.Equal("a", result.Item2[0].ToString());
+        Assert.Equal("b", result.Item2[1].ToString());
+    }
+
+    [SkipIfRedis(Is.OSSCluster, Comparison.LessThan, "7.0.0")]
+    public void TestBlmPopNoKeysProvided()
+    {
+        var redis = ConnectionMultiplexer.Connect("localhost");
+
+        var db = redis.GetDatabase(null);
+        db.Execute("FLUSHALL");
+
+        Assert.Throws<ArgumentException>(() => db.BzmPop(0, Array.Empty<RedisKey>(), MinMaxModifier.Min));
+    }
 
     [SkipIfRedis(Is.OSSCluster, Comparison.LessThan, "5.0.0")]
     public void TestBlPop()