Merge branch 'main' into tedhar/net9

libs/resources/RespCommandsDocs.json

@@ -6237,10 +6237,67 @@
       }
     ]
   },
+  {
+    "Command": "SETIFGREATER",
+    "Name": "SETIFGREATER",
+    "Summary": "Sets a key value pair with the given etag only if (1) the etag given in the request is greater than the already existing etag ; or (2) there was no existing value; or (3) the existing value was not associated with any etag and the sent etag was greater than 0.",
+    "Group": "String",
+    "Complexity": "O(1)",
+    "Arguments": [
+      {
+        "TypeDiscriminator": "RespCommandKeyArgument",
+        "Name": "KEY",
+        "DisplayText": "key",
+        "Type": "Key",
+        "KeySpecIndex": 0
+      },
+      {
+        "TypeDiscriminator": "RespCommandBasicArgument",
+        "Name": "VALUE",
+        "DisplayText": "value",
+        "Type": "String"
+      },
+      {
+        "TypeDiscriminator": "RespCommandBasicArgument",
+        "Name": "ETAG",
+        "DisplayText": "etag",
+        "Type": "Integer"
+      },
+      {
+        "TypeDiscriminator": "RespCommandContainerArgument",
+        "Name": "EXPIRATION",
+        "Type": "OneOf",
+        "ArgumentFlags": "Optional",
+        "Arguments": [
+          {
+            "TypeDiscriminator": "RespCommandBasicArgument",
+            "Name": "SECONDS",
+            "DisplayText": "seconds",
+            "Type": "Integer",
+            "Token": "EX"
+          },
+          {
+            "TypeDiscriminator": "RespCommandBasicArgument",
+            "Name": "MILLISECONDS",
+            "DisplayText": "milliseconds",
+            "Type": "Integer",
+            "Token": "PX"
+          }
+        ]
+      },
+      {
+        "TypeDiscriminator": "RespCommandBasicArgument",
+        "Name": "NOGET",
+        "DisplayText": "noget",
+        "Type": "PureToken",
+        "Token": "NOGET"
+      }
+    ]
+  },
   {
     "Command": "SETIFMATCH",
     "Name": "SETIFMATCH",
-    "Summary": "Sets the string value of a key, ignoring its type, if the key\u0027s current etag matches the given etag.",
+    "Summary": "Sets a key value pair with the given etag only if (1) the etag given in the request matches the already existing etag ; or (2) there was no existing value; or (3) the existing value was not associated with any etag and the sent etag was 0.",
     "Group": "String",
     "Complexity": "O(1)",
     "Arguments": [
@@ -6284,6 +6341,13 @@
             "Token": "PX"
           }
         ]
+      },
+      {
+        "TypeDiscriminator": "RespCommandBasicArgument",
+        "Name": "NOGET",
+        "DisplayText": "noget",
+        "Type": "PureToken",
+        "Token": "NOGET"
       }
     ]
   },

libs/resources/RespCommandsInfo.json

@@ -3975,6 +3975,30 @@
       }
     ]
   },
+  {
+    "Command": "SETIFGREATER",
+    "Name": "SETIFGREATER",
+    "Arity": -4,
+    "FirstKey": 1,
+    "LastKey": 1,
+    "Step": 1,
+    "AclCategories": "Slow, String, Write",
+    "KeySpecifications": [
+      {
+        "BeginSearch": {
+          "TypeDiscriminator": "BeginSearchIndex",
+          "Index": 1
+        },
+        "FindKeys": {
+          "TypeDiscriminator": "FindKeysRange",
+          "LastKey": 0,
+          "KeyStep": 1,
+          "Limit": 0
+        },
+        "Flags": "RW, Access, Update, VariableFlags"
+      }
+    ]
+  },
   {
     "Command": "SETIFMATCH",
     "Name": "SETIFMATCH",

libs/server/Resp/BasicCommands.cs

@@ -657,8 +657,8 @@ private bool NetworkSET_Conditional<TGarnetApi>(RespCommand cmd, int expiry, ref
 
             if (!getValue && !withEtag)
             {
-                // the following debug assertion is the catch any edge case leading to SETIFMATCH skipping the above block
-                Debug.Assert(cmd != RespCommand.SETIFMATCH, "SETIFMATCH should have gone though pointing to right output variable");
+                // the following debug assertion is the catch any edge case leading to SETIFMATCH, or SETIFGREATER skipping the above block
+                Debug.Assert(cmd is not (RespCommand.SETIFMATCH or RespCommand.SETIFGREATER), "SETIFMATCH should have gone though pointing to right output variable");
 
                 GarnetStatus status = storageApi.SET_Conditional(ref key, ref input);
 

libs/server/Resp/BasicEtagCommands.cs

@@ -77,37 +77,105 @@ private bool NetworkGETIFNOTMATCH<TGarnetApi>(ref TGarnetApi storageApi)
             return true;
         }
 
+
         /// <summary>
-        /// SETIFMATCH key val etag [EX|PX] [expiry]
-        /// Sets a key value pair only if the already existing etag matches the etag sent as a part of the request.
+        /// SETIFMATCH key val etag [EX|PX] [expiry] [NOGET]
+        /// Sets a key value pair with the given etag only if (1) the etag given in the request matches the already existing etag ;
+        /// or (2) there was no existing value; or (3) the existing value was not associated with any etag and the sent Etag was 0.
         /// </summary>
         /// <typeparam name="TGarnetApi"></typeparam>
         /// <param name="storageApi"></param>
         /// <returns></returns>
         private bool NetworkSETIFMATCH<TGarnetApi>(ref TGarnetApi storageApi)
             where TGarnetApi : IGarnetApi
         {
-            if (parseState.Count < 3 || parseState.Count > 5)
+            return NetworkSetETagConditional(RespCommand.SETIFMATCH, ref storageApi);
+        }
+
+
+        /// <summary>
+        /// SETIFGREATER key val etag [EX|PX] [expiry] [NOGET]
+        /// Sets a key value pair with the given etag only if (1) the etag given in the request is greater than the already existing etag ;
+        /// or (2) there was no existing value; or (3) the existing value was not associated with any etag.
+        /// </summary>
+        /// <typeparam name="TGarnetApi"></typeparam>
+        /// <param name="storageApi"></param>
+        /// <returns></returns>
+        private bool NetworkSETIFGREATER<TGarnetApi>(ref TGarnetApi storageApi)
+            where TGarnetApi : IGarnetApi
+        {
+            return NetworkSetETagConditional(RespCommand.SETIFGREATER, ref storageApi);
+        }
+
+        private bool NetworkSetETagConditional<TGarnetApi>(RespCommand cmd, ref TGarnetApi storageApi)
+            where TGarnetApi : IGarnetApi
+        {
+            // Currently only supports these two commands
+            Debug.Assert(cmd is RespCommand.SETIFMATCH or RespCommand.SETIFGREATER);
+
+            if (parseState.Count < 3 || parseState.Count > 6)
             {
-                return AbortWithWrongNumberOfArguments(nameof(RespCommand.SETIFMATCH));
+                return AbortWithWrongNumberOfArguments(nameof(cmd));
             }
 
             int expiry = 0;
             ReadOnlySpan<byte> errorMessage = default;
             var tokenIdx = 3;
 
             ExpirationOption expOption = ExpirationOption.None;
-            if (tokenIdx < parseState.Count)
+            bool noGet = false;
+
+            while (tokenIdx < parseState.Count)
             {
-                if (!parseState.TryGetExpirationOption(tokenIdx++, out expOption) || (expOption is not ExpirationOption.EX and not ExpirationOption.PX))
-                    errorMessage = CmdStrings.RESP_ERR_GENERIC_SYNTAX_ERROR;
-                else
+                // Parse NOGET option
+                if (parseState.GetArgSliceByRef(tokenIdx).Span.EqualsUpperCaseSpanIgnoringCase(CmdStrings.NOGET))
+                {
+                    if (noGet)
+                    {
+                        errorMessage = CmdStrings.RESP_ERR_GENERIC_SYNTAX_ERROR;
+                        break;
+                    }
+
+                    noGet = true;
+                    tokenIdx++;
+                    continue;
+                }
+
+                // Parse EX | PX expiry combination
+                if (parseState.TryGetExpirationOption(tokenIdx, out expOption))
                 {
-                    if (!parseState.TryGetInt(tokenIdx++, out expiry))
+                    if (expOption is not ExpirationOption.EX and not ExpirationOption.PX)
+                    {
+                        errorMessage = CmdStrings.RESP_ERR_GENERIC_SYNTAX_ERROR;
+                        break;
+                    }
+
+                    // we know that the token is either EX or PX from above and the next value should be the expiry
+                    tokenIdx++;
+                    if (!parseState.TryGetInt(tokenIdx, out expiry))
+                    {
                         errorMessage = CmdStrings.RESP_ERR_GENERIC_VALUE_IS_NOT_INTEGER;
+                        break;
+                    }
                     else if (expiry <= 0)
+                    {
                         errorMessage = CmdStrings.RESP_ERR_GENERIC_INVALIDEXP_IN_SET;
+                        break;
+                    }
+
+                    tokenIdx++;
+                    continue;
                 }
+
+                // neither NOGET nor EX|PX expiry combination
+                errorMessage = CmdStrings.RESP_ERR_GENERIC_SYNTAX_ERROR;
+                break;
+            }
+
+            bool etagRead = parseState.TryGetLong(2, out long etag);
+            if (!etagRead || etag < 0)
+            {
+                errorMessage = CmdStrings.RESP_ERR_INVALID_ETAG;
             }
 
             if (!errorMessage.IsEmpty)
@@ -119,7 +187,7 @@ private bool NetworkSETIFMATCH<TGarnetApi>(ref TGarnetApi storageApi)
 
             SpanByte key = parseState.GetArgSliceByRef(0).SpanByte;
 
-            NetworkSET_Conditional(RespCommand.SETIFMATCH, expiry, ref key, getValue: true, highPrecision: expOption == ExpirationOption.PX, withEtag: true, ref storageApi);
+            NetworkSET_Conditional(cmd, expiry, ref key, getValue: !noGet, highPrecision: expOption == ExpirationOption.PX, withEtag: true, ref storageApi);
 
             return true;
         }

libs/server/Resp/CmdStrings.cs

@@ -144,9 +144,11 @@ static partial class CmdStrings
         public static ReadOnlySpan<byte> GETWITHETAG => "GETWITHETAG"u8;
         public static ReadOnlySpan<byte> GETIFNOTMATCH => "GETIFNOTMATCH"u8;
         public static ReadOnlySpan<byte> SETIFMATCH => "SETIFMATCH"u8;
+        public static ReadOnlySpan<byte> SETIFGREATER => "SETIFGREATER"u8;
         public static ReadOnlySpan<byte> FIELDS => "FIELDS"u8;
         public static ReadOnlySpan<byte> TIMEOUT => "TIMEOUT"u8;
         public static ReadOnlySpan<byte> ERROR => "ERROR"u8;
+        public static ReadOnlySpan<byte> NOGET => "NOGET"u8;
 
         /// <summary>
         /// Response strings
@@ -251,9 +253,11 @@ static partial class CmdStrings
         public static ReadOnlySpan<byte> RESP_COMMAND_HAS_NO_KEY_ARGS => "The command has no key arguments"u8;
         public static ReadOnlySpan<byte> RESP_ERR_INVALID_CLIENT_UNBLOCK_REASON => "ERR CLIENT UNBLOCK reason should be TIMEOUT or ERROR"u8;
         public static ReadOnlySpan<byte> RESP_UNBLOCKED_CLIENT_VIA_CLIENT_UNBLOCK => "UNBLOCKED client unblocked via CLIENT UNBLOCK"u8;
+        public static ReadOnlySpan<byte> RESP_ERR_INVALID_ETAG => "ETAG must be a numerical value greater than or equal to 0"u8;
         public static ReadOnlySpan<byte> RESP_ERR_DEUBG_DISALLOWED =>
             @"ERR DEBUG command not allowed. If the EnableDebugCommand option is set to ""local"", you can run it from a local connection, otherwise you need to set this option in the configuration file, and then restart the server."u8;
 
+
         /// <summary>
         /// Response string templates
         /// </summary>

libs/server/Resp/Parser/RespCommand.cs

@@ -174,6 +174,7 @@ public enum RespCommand : ushort
         SETEXXX,
         SETNX,
         SETIFMATCH,
+        SETIFGREATER,
         SETKEEPTTL,
         SETKEEPTTLXX,
         SETRANGE,
@@ -2448,6 +2449,10 @@ private RespCommand SlowParseCommand(ref int count, ref ReadOnlySpan<byte> speci
                 {
                     return RespCommand.SETIFMATCH;
                 }
+                else if (command.SequenceEqual(CmdStrings.SETIFGREATER))
+                {
+                    return RespCommand.SETIFGREATER;
+                }
                 else if (command.SequenceEqual(CmdStrings.GETWITHETAG))
                 {
                     return RespCommand.GETWITHETAG;

libs/server/Resp/RespServerSession.cs

@@ -866,6 +866,7 @@ private bool ProcessOtherCommands<TGarnetApi>(RespCommand command, ref TGarnetAp
                 RespCommand.GETWITHETAG => NetworkGETWITHETAG(ref storageApi),
                 RespCommand.GETIFNOTMATCH => NetworkGETIFNOTMATCH(ref storageApi),
                 RespCommand.SETIFMATCH => NetworkSETIFMATCH(ref storageApi),
+                RespCommand.SETIFGREATER => NetworkSETIFGREATER(ref storageApi),
 
                 _ => Process(command, ref storageApi)
             };

libs/server/Storage/Functions/EtagState.cs

@@ -9,7 +9,7 @@ internal static class EtagConstants
     {
         public const byte EtagSize = sizeof(long);
 
-        public const long BaseEtag = 0;
+        public const long NoETag = 0;
     }
 
     /// <summary>
@@ -39,7 +39,7 @@ public EtagState()
         /// <summary>
         /// Field provides access to getting an Etag from a record, hiding whether it is actually present or not.
         /// </summary>
-        public long etag { get; private set; } = EtagConstants.BaseEtag;
+        public long etag { get; set; } = EtagConstants.NoETag;
 
         /// <summary>
         /// Sets the values to indicate the presence of an Etag as a part of the payload value
@@ -56,7 +56,7 @@ public static void ResetState(ref EtagState curr)
         {
             curr.etagOffsetForVarlen = 0;
             curr.etagSkippedStart = 0;
-            curr.etag = EtagConstants.BaseEtag;
+            curr.etag = EtagConstants.NoETag;
             curr.etagAccountedLength = -1;
         }
     }

libs/server/Storage/Functions/MainStore/PrivateMethods.cs

@@ -663,7 +663,7 @@ static void CopyRespWithEtagData(ref SpanByte value, ref SpanByteAndMemory dst,
             int desiredLength = 4;
             ReadOnlySpan<byte> etagTruncatedVal;
             // get etag to write, default etag 0 for when no etag
-            long etag = hasEtagInVal ? value.GetEtagInPayload() : EtagConstants.BaseEtag;
+            long etag = hasEtagInVal ? value.GetEtagInPayload() : EtagConstants.NoETag;
             // remove the length of the ETAG
             var etagAccountedValueLength = valueLength - etagSkippedStart;
             if (hasEtagInVal)