Add more blocking commands (#253)

* Rename existing blocking commands

The current naming for the blocking commands does not feel right. For
example "BzmPop", it feels like there are no naming rules. So rename
existing methods by this rule: Use capital letters at the beginning of
human-readable words, e.g. "Pop", and also use capital letters where the
Redis command has a single letter, e.g. "B", which stands for
"Blocking", "Z" which stands for "Set" and "M" which stands for "Multi".
So the new name is "BZMPop".

It's still a good time to do such renaming, because these commands have
not been released. Also it is a crucial moment to get the naming as
right as possible, for the same reason.

* Add ToString to RedisValueWithScore

* Add support for BLPOP and BRPOP commands

Issues #249 and #250

* Add support for the BLMPOP command

Issue #248

* Add support for the BLMOVE and BRPOPLPUSH commands

Issues #235 and #251

* Try to fix flaky test

* Use Redis fixture in CoreTests

* Remove ToString, not really needed

---------

Co-authored-by: Gabriel Erzse <[email protected]>
Co-authored-by: shacharPash <[email protected]>

Author: 3 people

src/NRedisStack/CoreCommands/CoreCommandBuilder.cs

@@ -21,7 +21,7 @@ public static SerializedCommand ClientSetInfo(SetInfoAttr attr, string value)
             return new SerializedCommand(RedisCoreCommands.CLIENT, RedisCoreCommands.SETINFO, attrValue, value);
         }
 
-        public static SerializedCommand BzmPop(double timeout, RedisKey[] keys, MinMaxModifier minMaxModifier, long? count)
+        public static SerializedCommand BZMPop(double timeout, RedisKey[] keys, MinMaxModifier minMaxModifier, long? count)
         {
             if (keys.Length == 0)
             {
@@ -44,21 +44,72 @@ public static SerializedCommand BzmPop(double timeout, RedisKey[] keys, MinMaxMo
             return new SerializedCommand(RedisCoreCommands.BZMPOP, args);
         }
 
-        public static SerializedCommand BzPopMin(RedisKey[] keys, double timeout)
+        public static SerializedCommand BZPopMin(RedisKey[] keys, double timeout)
+        {
+            return BlockingCommandWithKeysAndTimeout(RedisCoreCommands.BZPOPMIN, keys, timeout);
+        }
+
+        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);
+        }
+
+        public static SerializedCommand BRPop(RedisKey[] keys, double timeout)
+        {
+            return BlockingCommandWithKeysAndTimeout(RedisCoreCommands.BRPOP, keys, timeout);
+        }
+
+        public static SerializedCommand BLMove(RedisKey source, RedisKey destination, ListSide sourceSide, ListSide destinationSide, double timeout)
+        {
+            List<object> args = new List<object>();
+            args.Add(source);
+            args.Add(destination);
+            args.Add(sourceSide == ListSide.Left ? CoreArgs.LEFT : CoreArgs.RIGHT);
+            args.Add(destinationSide == ListSide.Left ? CoreArgs.LEFT : CoreArgs.RIGHT);
+            args.Add(timeout);
+
+            return new SerializedCommand(RedisCoreCommands.BLMOVE, args);
+        }
+
+        public static SerializedCommand BRPopLPush(RedisKey source, RedisKey destination, double timeout)
+        {
+            List<object> args = new List<object>();
+            args.Add(source);
+            args.Add(destination);
             args.Add(timeout);
 
-            return new SerializedCommand(RedisCoreCommands.BZPOPMIN, args);
+            return new SerializedCommand(RedisCoreCommands.BRPOPLPUSH, args);
         }
 
-        public static SerializedCommand BzPopMax(RedisKey[] keys, double timeout)
+        private static SerializedCommand BlockingCommandWithKeysAndTimeout(String command, RedisKey[] keys, double timeout)
         {
             if (keys.Length == 0)
             {
@@ -69,7 +120,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

@@ -28,4 +28,4 @@ public RedisValueWithScore(RedisValue value, double score)
     /// <c>ZADD my-set 5.1 my-value</c>, the score is <c>5.1</c>.
     /// </summary>
     public double Score { get; }
-}
+}

src/NRedisStack/CoreCommands/DataTypes/RedisValueWithScore.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/CommandArgs.cs

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

src/NRedisStack/CoreCommands/Literals/Commands.cs

@@ -766,5 +766,41 @@ 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);
+        }
+
+        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);
+        }
     }
 }