Adds new module context flag VALKEYMODULE_CTX_SCRIPT_EXECUTION

The new module context flag `VALKEYMODULE_CTX_SCRIPT_EXECUTION` denotes
that the module API function is being called in the context of a
scripting engine execution.

Signed-off-by: Ricardo Dias <ricardo.dias@percona.com>

Author: rjd15372

src/module.c

@@ -201,6 +201,7 @@ typedef struct ValkeyModuleCtx ValkeyModuleCtx;
 #define VALKEYMODULE_CTX_CHANNELS_POS_REQUEST (1 << 8)
 #define VALKEYMODULE_CTX_COMMAND (1 << 9)                /* Context created to serve a command from call() or AOF (which calls cmd->proc directly) */
 #define VALKEYMODULE_CTX_KEYSPACE_NOTIFICATION (1 << 10) /* Context created a keyspace notification event */
+#define VALKEYMODULE_CTX_SCRIPT_EXECUTION (1 << 11)        /* Context created to serve a scripting engine execution */
 
 /* This represents a key opened with VM_OpenKey(). */
 struct ValkeyModuleKey {
@@ -997,7 +998,7 @@ void moduleCreateContext(ValkeyModuleCtx *out_ctx, ValkeyModule *module, int ctx
 void moduleScriptingEngineInitContext(ValkeyModuleCtx *out_ctx,
                                       ValkeyModule *module,
                                       client *client) {
-    moduleCreateContext(out_ctx, module, VALKEYMODULE_CTX_NONE);
+    moduleCreateContext(out_ctx, module, VALKEYMODULE_CTX_SCRIPT_EXECUTION);
     out_ctx->client = client;
 }
 
@@ -6420,6 +6421,12 @@ ValkeyModuleCallReply *VM_Call(ValkeyModuleCtx *ctx, const char *cmdname, const
     error_as_call_replies = flags & VALKEYMODULE_ARGV_CALL_REPLIES_AS_ERRORS;
     va_end(ap);
 
+    int is_running_script = ctx->flags & VALKEYMODULE_CTX_SCRIPT_EXECUTION;
+
+    /* If we're calling a command with a script execution context, then a script
+     * execution runtime must exist.. */
+    serverAssert(!is_running_script || scriptIsRunning());
+
     c = moduleAllocTempClient();
 
     if (!(flags & VALKEYMODULE_ARGV_ALLOW_BLOCK)) {
@@ -6483,18 +6490,18 @@ ValkeyModuleCallReply *VM_Call(ValkeyModuleCtx *ctx, const char *cmdname, const
     cmd_flags = getCommandFlags(c);
 
     if (flags & VALKEYMODULE_ARGV_SCRIPT_MODE) {
-        if (scriptIsRunning()) {
+        if (is_running_script) {
             c->flag.module = 0;
             c->flag.script = 1;
         }
 
         /* In script mode, commands with CMD_NOSCRIPT flag are normally forbidden.
          * However, we allow them if both conditions are met:
-         * 1. We're running in the context of a scripting engine (scriptIsRunning())
+         * 1. We're running in the context of a scripting engine running a script
          * 2. The configuration option server.script_disable_deny_script is enabled
          * If either condition is false, we block the command. */
         if ((cmd_flags & CMD_NOSCRIPT)) {
-            if (!scriptIsRunning() || !server.script_disable_deny_script) {
+            if (!is_running_script || !server.script_disable_deny_script) {
                 errno = ESPIPE;
                 if (error_as_call_replies) {
                     reply_error_msg = sdscatfmt(sdsempty(), "command '%S' is not allowed on script mode", c->cmd->fullname);
@@ -6503,7 +6510,7 @@ ValkeyModuleCallReply *VM_Call(ValkeyModuleCtx *ctx, const char *cmdname, const
             }
         }
 
-        if (scriptIsRunning() && scriptAllowsOOM()) {
+        if (is_running_script && scriptAllowsOOM()) {
             flags &= ~VALKEYMODULE_ARGV_RESPECT_DENY_OOM;
         }
     }
@@ -6611,15 +6618,16 @@ ValkeyModuleCallReply *VM_Call(ValkeyModuleCtx *ctx, const char *cmdname, const
          * Note: For scripts, we consider may-replicate commands as write commands.
          * This also makes it possible to allow read-only scripts to be run during
          * CLIENT PAUSE WRITE. */
-        if (scriptIsRunning() && scriptIsReadOnly() && (cmd_flags & (CMD_WRITE | CMD_MAY_REPLICATE))) {
+        if (is_running_script && scriptIsReadOnly() && (cmd_flags & (CMD_WRITE | CMD_MAY_REPLICATE))) {
             errno = ENOSPC;
             reply_error_msg = sdsnew("Write commands are not allowed from read-only scripts");
             goto cleanup;
         }
 
         /* If the script already made a modification to the dataset, we can't
          * fail it on unpredictable error state. */
-        if ((scriptIsRunning() && !scriptIsWriteDirty() && cmd_flags & CMD_WRITE) || (!scriptIsRunning() && cmd_flags & CMD_WRITE)) {
+        if ((is_running_script && !scriptIsWriteDirty() && cmd_flags & CMD_WRITE) ||
+            (!is_running_script && cmd_flags & CMD_WRITE)) {
             /* on script mode, if a command is a write command,
              * We will not run it if we encounter disk error
              * or we do not have enough replicas */
@@ -6651,7 +6659,7 @@ ValkeyModuleCallReply *VM_Call(ValkeyModuleCtx *ctx, const char *cmdname, const
                 goto cleanup;
             }
 
-            if (scriptIsRunning()) {
+            if (is_running_script) {
                 scriptSetWriteDirtyFlag();
             }
         }
@@ -6660,7 +6668,7 @@ ValkeyModuleCallReply *VM_Call(ValkeyModuleCtx *ctx, const char *cmdname, const
             !(cmd_flags & CMD_STALE)) {
             errno = ESPIPE;
             if (error_as_call_replies) {
-                if (scriptIsRunning()) {
+                if (is_running_script) {
                     reply_error_msg = sdsnew("Can not execute the command on a stale replica");
                 } else {
                     reply_error_msg = sdsdup(shared.primarydownerr->ptr);
@@ -6669,7 +6677,7 @@ ValkeyModuleCallReply *VM_Call(ValkeyModuleCtx *ctx, const char *cmdname, const
             goto cleanup;
         }
 
-        if (scriptIsRunning() && server.cluster_enabled && !mustObeyClient(ctx->client)) {
+        if (is_running_script && server.cluster_enabled && !mustObeyClient(ctx->client)) {
             if (c->slot != -1 && !scriptAllowsCrossSlot()) {
                 if (scriptGetSlot() == -1) {
                     scriptSetSlot(c->slot);
@@ -6710,7 +6718,7 @@ ValkeyModuleCallReply *VM_Call(ValkeyModuleCtx *ctx, const char *cmdname, const
 
     if (c->flag.blocked) {
         /* Blocking commands are not allowed when calling commands in scripting engines. */
-        serverAssert(!scriptIsRunning());
+        serverAssert(!is_running_script);
         serverAssert(flags & VALKEYMODULE_ARGV_ALLOW_BLOCK);
         serverAssert(ctx->module);
         ValkeyModuleAsyncRMCallPromise *promise = zmalloc(sizeof(ValkeyModuleAsyncRMCallPromise));