Unified Lua and modules reply parsing and added RESP3 support to RM_Call (#9202)

## Current state
1. Lua has its own parser that handles parsing `reds.call` replies and translates them
  to Lua objects that can be used by the user Lua code. The parser partially handles
  resp3 (missing big number, verbatim, attribute, ...)
2. Modules have their own parser that handles parsing `RM_Call` replies and translates
  them to RedisModuleCallReply objects. The parser does not support resp3.

In addition, in the future, we want to add Redis Function (#8693) that will probably
support more languages. At some point maintaining so many parsers will stop
scaling (bug fixes and protocol changes will need to be applied on all of them).
We will probably end up with different parsers that support different parts of the
resp protocol (like we already have today with Lua and modules)

## PR Changes
This PR attempt to unified the reply parsing of Lua and modules (and in the future
Redis Function) by introducing a new parser unit (`resp_parser.c`). The new parser
handles parsing the reply and calls different callbacks to allow the users (another
unit that uses the parser, i.e, Lua, modules, or Redis Function) to analyze the reply.

### Lua API Additions
The code that handles reply parsing on `scripting.c` was removed. Instead, it uses
the resp_parser to parse and create a Lua object out of the reply. As mentioned
above the Lua parser did not handle parsing big numbers, verbatim, and attribute.
The new parser can handle those and so Lua also gets it for free.
Those are translated to Lua objects in the following way:
1. Big Number - Lua table `{'big_number':'<str representation for big number>'}`
2. Verbatim - Lua table `{'verbatim_string':{'format':'<verbatim format>', 'string':'<verbatim string value>'}}`
3. Attribute - currently ignored and not expose to the Lua parser, another issue will be open to decide how to expose it.

Tests were added to check resp3 reply parsing on Lua

### Modules API Additions
The reply parsing code on `module.c` was also removed and the new resp_parser is used instead.
In addition, the RedisModuleCallReply was also extracted to a separate unit located on `call_reply.c`
(in the future, this unit will also be used by Redis Function). A nice side effect of unified parsing is
that modules now also support resp3. Resp3 can be enabled by giving `3` as a parameter to the
fmt argument of `RM_Call`. It is also possible to give `0`, which will indicate an auto mode. i.e, Redis
will automatically chose the reply protocol base on the current client set on the RedisModuleCtx
(this mode will mostly be used when the module want to pass the reply to the client as is).
In addition, the following RedisModuleAPI were added to allow analyzing resp3 replies:

* New RedisModuleCallReply types:
   * `REDISMODULE_REPLY_MAP`
   * `REDISMODULE_REPLY_SET`
   * `REDISMODULE_REPLY_BOOL`
   * `REDISMODULE_REPLY_DOUBLE`
   * `REDISMODULE_REPLY_BIG_NUMBER`
   * `REDISMODULE_REPLY_VERBATIM_STRING`
   * `REDISMODULE_REPLY_ATTRIBUTE`

* New RedisModuleAPI:
   * `RedisModule_CallReplyDouble` - getting double value from resp3 double reply
   * `RedisModule_CallReplyBool` - getting boolean value from resp3 boolean reply
   * `RedisModule_CallReplyBigNumber` - getting big number value from resp3 big number reply
   * `RedisModule_CallReplyVerbatim` - getting format and value from resp3 verbatim reply
   * `RedisModule_CallReplySetElement` - getting element from resp3 set reply
   * `RedisModule_CallReplyMapElement` - getting key and value from resp3 map reply
   * `RedisModule_CallReplyAttribute` - getting a reply attribute
   * `RedisModule_CallReplyAttributeElement` - getting key and value from resp3 attribute reply
   
* New context flags:
   * `REDISMODULE_CTX_FLAGS_RESP3` - indicate that the client is using resp3

Tests were added to check the new RedisModuleAPI

### Modules API Changes
* RM_ReplyWithCallReply might return REDISMODULE_ERR if the given CallReply is in resp3
  but the client expects resp2. This is not a breaking change because in order to get a resp3
  CallReply one needs to specifically specify `3` as a parameter to the fmt argument of
  `RM_Call` (as mentioned above).

Tests were added to check this change

### More small Additions
* Added `debug set-disable-deny-scripts` that allows to turn on and off the commands no-script
flag protection. This is used by the Lua resp3 tests so it will be possible to run `debug protocol`
and check the resp3 parsing code.

Co-authored-by: Oran Agra <oran@redislabs.com>
Co-authored-by: Yossi Gottlieb <yossigo@gmail.com>

1 files changed, 94 insertions, 0 deletions

diff --git a/src/resp_parser.h b/src/resp_parser.h
new file mode 100644
index 000000000..4597efee3
--- /dev/null
+++ b/src/resp_parser.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2021, Redis Labs Ltd.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef SRC_RESP_PARSER_H_
+#define SRC_RESP_PARSER_H_
+
+#include <stddef.h>
+
+typedef struct ReplyParser ReplyParser;
+
+typedef struct ReplyParserCallbacks {
+    /* Called when the parser reaches an empty mbulk ('*-1') */
+    void (*null_array_callback)(void *ctx, const char *proto, size_t proto_len);
+
+    /* Called when the parser reaches an empty bulk ('$-1') (bulk len is -1) */
+    void (*null_bulk_string_callback)(void *ctx, const char *proto, size_t proto_len);
+
+    /* Called when the parser reaches a bulk ('$'), which is passed as 'str' along with its length 'len' */
+    void (*bulk_string_callback)(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len);
+
+    /* Called when the parser reaches an error ('-'), which is passed as 'str' along with its length 'len' */
+    void (*error_callback)(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len);
+
+    /* Called when the parser reaches a simple string ('+'), which is passed as 'str' along with its length 'len' */
+    void (*simple_str_callback)(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len);
+
+    /* Called when the parser reaches a long long value (':'), which is passed as an argument 'val' */
+    void (*long_callback)(void *ctx, long long val, const char *proto, size_t proto_len);
+
+    /* Called when the parser reaches an array ('*'). The array length is passed as an argument 'len' */
+    void (*array_callback)(struct ReplyParser *parser, void *ctx, size_t len, const char *proto);
+
+    /* Called when the parser reaches a set ('~'). The set length is passed as an argument 'len' */
+    void (*set_callback)(struct ReplyParser *parser, void *ctx, size_t len, const char *proto);
+
+    /* Called when the parser reaches a map ('%'). The map length is passed as an argument 'len' */
+    void (*map_callback)(struct ReplyParser *parser, void *ctx, size_t len, const char *proto);
+
+    /* Called when the parser reaches a bool ('#'), which is passed as an argument 'val' */
+    void (*bool_callback)(void *ctx, int val, const char *proto, size_t proto_len);
+
+    /* Called when the parser reaches a double (','), which is passed as an argument 'val' */
+    void (*double_callback)(void *ctx, double val, const char *proto, size_t proto_len);
+
+    /* Called when the parser reaches a big number (','), which is passed as 'str' along with its length 'len' */
+    void (*big_number_callback)(void *ctx, const char *str, size_t len, const char *proto, size_t proto_len);
+
+    /* Called when the parser reaches a string, which is passed as 'str' along with its 'format' and length 'len' */
+    void (*verbatim_string_callback)(void *ctx, const char *format, const char *str, size_t len, const char *proto, size_t proto_len);
+
+    /* Called when the parser reaches an attribute ('|'). The attribute length is passed as an argument 'len' */
+    void (*attribute_callback)(struct ReplyParser *parser, void *ctx, size_t len, const char *proto);
+
+    /* Called when the parser reaches a null ('_') */
+    void (*null_callback)(void *ctx, const char *proto, size_t proto_len);
+
+    void (*error)(void *ctx);
+} ReplyParserCallbacks;
+
+struct ReplyParser {
+    /* The current location in the reply buffer, needs to be set to the beginning of the reply */
+    const char *curr_location;
+    ReplyParserCallbacks callbacks;
+};
+
+int parseReply(ReplyParser *parser, void *p_ctx);
+
+#endif /* SRC_RESP_PARSER_H_ */