durable_rules 0.33.13 → 0.34.01

data/src/rules/net.c

@@ -2,6 +2,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
+#include <errno.h>
 #include "net.h"
 #include "rules.h"
 #include "json.h"
@@ -894,7 +895,6 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "local events_mids_cache = {}\n"
 "local context_directory = {}\n"
 "local input_keys = {}\n"
-"local candidate = nil\n"
 "local toggle\n"
 "local expressions_count\n"
 "local results\n"
@@ -1138,7 +1138,6 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "end\n"
 "local process_key_with_span = function(message, span)\n"
 "    local index = directory[key]\n"
-"    local next_result = nil\n"
 "    local queue_lock = false\n"
 "    if index then\n"
 "        local last_score = redis.call(\"get\", results_key .. \"!d\")\n"
@@ -1176,11 +1175,10 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "            end\n"
 "        end\n"
 "    end\n"
-"    return queue_lock, next_result\n"
+"    return queue_lock\n"
 "end\n"
 "local process_key_with_cap = function(message, cap)\n"
 "    local index = directory[key]\n"
-"    local next_result = nil\n"
 "    local queue_lock = false\n"
 "    if index then\n"
 "        local count = 0\n"
@@ -1204,20 +1202,6 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "            local diff\n"
 "            local new_count, new_remain = math.modf(#results / cap)\n"
 "            local new_remain = #results %% cap\n"
-"            if redis.call(\"llen\", actions_key .. \"!\" .. sid) == 2 then\n"
-"                local frames = {}\n"
-"                if new_count > 0 then\n"
-"                    for i = 0, cap - 1, 1 do\n"
-"                        table.insert(frames, unpacked_results[#unpacked_results - i])\n"
-"                    end\n"
-"                else\n"
-"                    for i = 0, new_remain - 1, 1 do\n"
-"                        table.insert(frames, unpacked_results[#unpacked_results - i])\n"
-"                    end\n"
-"                end\n"
-"                local last_name = string.find(results_key, \"!\") - 1\n"
-"                next_result = {[string.sub(results_key, 1, last_name)] = frames}\n"
-"            end\n"
 "            if new_count > 0 then\n"
 "                for i = 1, new_count, 1 do\n"
 "                    redis.call(\"rpush\", actions_key .. \"!\" .. sid, results_key)\n"
@@ -1233,11 +1217,10 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "            end\n"
 "        end\n"
 "    end\n"
-"    return queue_lock, next_result\n"
+"    return queue_lock\n"
 "end\n"
 "local process_key_with_window = function(message, window)\n"
 "    local index = directory[key]\n"
-"    local next_result = nil\n"
 "    local queue_lock = false\n"
 "    if index then\n"
 "        local count = 0\n"
@@ -1264,18 +1247,6 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "            local new_count, prev_remain = math.modf(length / window)\n"
 "            diff = new_count - prev_count\n"
 "            if diff > 0 then\n"
-"                if redis.call(\"llen\", actions_key .. \"!\" .. sid) == 2 then\n"
-"                    local frames = {}\n"
-"                    for i = 0, window - 1, 1 do\n"
-"                        table.insert(frames, unpacked_results[#unpacked_results - i])\n"
-"                    end\n"
-"                    local last_name = string.find(results_key, \"!\") - 1\n"
-"                    if window == 1 then\n"
-"                        next_result = {[string.sub(results_key, 1, last_name)] = frames[1]}\n"
-"                    else\n"
-"                        next_result = {[string.sub(results_key, 1, last_name)] = frames}\n"
-"                    end\n"
-"                end\n"
 "                for i = 0, diff - 1, 1 do\n"
 "                    redis.call(\"rpush\", actions_key .. \"!\" .. sid, results_key)\n"
 "                    if window == 1 then\n"
@@ -1288,7 +1259,7 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "             end\n"
 "        end\n"
 "    end\n"
-"    return queue_lock, next_result\n"
+"    return queue_lock\n"
 "end\n"
 "local message = nil\n"
 "if #ARGV > (6 + keys_count) then\n"
@@ -1341,11 +1312,7 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "    expressions_count = context[\"expressions_count\"]\n"
 "    local process_key = context[\"process_key\"]\n"
 "    local process_key_count = context[\"process_key_count\"]\n"
-"    local new_candidate\n"
-"    queue_action, new_candidate = process_key(message, process_key_count)\n"
-"    if new_candidate then\n"
-"        candidate = new_candidate\n"
-"    end\n"
+"    queue_action = process_key(message, process_key_count)\n"
 "    if assert_fact == 0 and events_message_cache[tostring(message[\"id\"])] == false then\n"
 "        break\n"
 "    end\n"
@@ -1355,14 +1322,7 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "        redis.call(\"zadd\", actions_key , score, sid)\n"
 "    end\n"
 "end\n"
-"if not candidate then\n"
-"    if redis.call(\"llen\", actions_key .. \"!\" .. sid) > 2 then\n"
-"    end\n"
-"    return nil\n"
-"else\n"
-"    redis.call(\"set\", \"skip\", \"yes\")\n"
-"    return {sid, cjson.encode(candidate)}\n"
-"end\n",
+"return nil\n",
                  name,
                  name,
                  name,
@@ -1388,10 +1348,6 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
     free(lua);
 
     if (asprintf(&lua, 
-"if redis.call(\"get\", \"skip\") == \"yes\" then\n"
-"    redis.call(\"set\", \"skip\", \"no\")\n"
-"    return nil\n"
-"end\n"
 "local facts_key = \"%s!f!\"\n"
 "local events_key = \"%s!e!\"\n"
 "local action_key = \"%s!a\"\n"
@@ -1567,7 +1523,7 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "end\n"
 "local load_frame = function(max_score)\n"
 "    local current_action = redis.call(\"zrange\", action_key, 0, 0, \"withscores\")\n"
-"    if #current_action == 0 or (tonumber(current_action[2]) > (max_score + 5)) then\n"
+"    if (#current_action == 0) or (tonumber(current_action[2]) > (max_score + 5)) then\n"
 "        return nil, nil, nil\n"
 "    end\n"
 "    local sid = current_action[1]\n"
@@ -1592,13 +1548,13 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "local new_sid, action_name, frame\n"
 "if #ARGV == 3 then\n"
 "    new_sid = ARGV[3]\n"
-"    action_name, frame = load_frame_from_sid(new_sid, ARGV[2])\n"
+"    action_name, frame = load_frame_from_sid(new_sid, tonumber(ARGV[2]))\n"
 "else\n"
 "    new_sid, action_name, frame = load_frame(tonumber(ARGV[2]))\n"
 "end\n"
 "if frame then\n"
+"    redis.call(\"zadd\", action_key, tonumber(ARGV[1]), new_sid)\n"
 "    if #ARGV == 2 then\n"
-"        redis.call(\"zincrby\", action_key, tonumber(ARGV[1]), new_sid)\n"
 "        local state = redis.call(\"hget\", state_key, new_sid)\n"
 "        return {new_sid, state, cjson.encode({[action_name] = frame})}\n"
 "    else\n"
@@ -1706,7 +1662,7 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
     free(lua);
 
     if (asprintf(&lua, 
-"local delete_frame = function(key)\n"
+"local delete_frame = function(key, action_key)\n"
 "    local rule_action_key = redis.call(\"lpop\", key)\n"
 "    local raw_count = redis.call(\"lpop\", key)\n"
 "    local count = 1\n"
@@ -1720,7 +1676,7 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "        end\n"
 "    else\n"
 "        for i = 0, count - 1, 1 do\n"
-"            redis.call(\"lpop\", rule_action_key)\n"
+"            local packed_frame = redis.call(\"rpop\", rule_action_key)\n"
 "        end\n"
 "    end\n"
 "    return (redis.call(\"llen\", key) > 0)\n"
@@ -1728,14 +1684,10 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "local sid = ARGV[1]\n"
 "local max_score = tonumber(ARGV[2])\n"
 "local action_key = \"%s!a\"\n"
-"if delete_frame(action_key .. \"!\" .. sid) then\n"
-//"    if redis.call(\"get\", \"skip\") ~= \"yes\" then\n"
-"        redis.call(\"zadd\", action_key, max_score, sid)\n"
-//"    end\n"
+"if delete_frame(action_key .. \"!\" .. sid, action_key) then\n"
+"    redis.call(\"zadd\", action_key , max_score, sid)\n"
 "else\n"
-//"    if redis.call(\"get\", \"skip\") ~= \"yes\" then\n"
-"        redis.call(\"zrem\", action_key, sid)\n"
-//"    end\n"
+"    redis.call(\"zrem\", action_key, sid)\n"
 "end\n", name)  == -1) {
         return ERR_OUT_OF_MEMORY;
     }
@@ -1806,6 +1758,29 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
     freeReplyObject(reply);
     free(lua);
 
+    if (asprintf(&lua,
+"local actions_key = \"%s!a\"\n"
+"local score = tonumber(ARGV[2])\n"
+"local sid = ARGV[1]\n"
+"if redis.call(\"zscore\", actions_key, sid) then\n"
+"    redis.call(\"zadd\", actions_key , score, sid)\n"
+"end\n", name)  == -1) {
+        return ERR_OUT_OF_MEMORY;
+    }
+
+    redisAppendCommand(reContext, "SCRIPT LOAD %s", lua);
+    redisGetReply(reContext, (void**)&reply);
+    if (reply->type == REDIS_REPLY_ERROR) {
+        printf("%s\n", reply->str);
+        freeReplyObject(reply);
+        return ERR_REDIS_ERROR;
+    }
+
+    strncpy(rulesBinding->updateActionHash, reply->str, 40);
+    rulesBinding->updateActionHash[40] = '\0';
+    freeReplyObject(reply);
+    free(lua);
+
     char *sessionHashset = malloc((nameLength + 3) * sizeof(char));
     if (!sessionHashset) {
         return ERR_OUT_OF_MEMORY;
@@ -1887,8 +1862,16 @@ unsigned int bindRuleset(void *handle,
         return ERR_CONNECT_REDIS;
     }
 
+    struct timeval tv;
+    tv.tv_sec = 10;
+    tv.tv_usec = 0;
+    int result = redisSetTimeout(reContext, tv);
+    if (result != REDIS_OK) {
+        return ERR_REDIS_ERROR;
+    }
+
     if (password != NULL) {
-        int result = redisAppendCommand(reContext, "auth %s", password);
+        result = redisAppendCommand(reContext, "auth %s", password);
         if (result != REDIS_OK) {
             return ERR_REDIS_ERROR;
         }
@@ -2012,7 +1995,7 @@ unsigned int formatEvalMessage(void *rulesBinding,
     argv[4] = mid;
     argvl[4] = strlen(mid);
     argv[5] = score;
-    argvl[5] = 10;
+    argvl[5] = strlen(score);
     argv[6] = (actionType == ACTION_ASSERT_FACT || actionType == ACTION_RETRACT_FACT) ? "1" : "0";
     argvl[6] = 1;
     argv[7] = keysLengthString;
@@ -2268,7 +2251,7 @@ unsigned int formatPeekAction(void *rulesBinding,
     int result = redisFormatCommand(command, 
                                     "evalsha %s 0 %d %ld %s", 
                                     currentBinding->peekActionHash, 
-                                    60,
+                                    currentTime + 15,
                                     currentTime,
                                     sid); 
     if (result == 0) {
@@ -2291,22 +2274,22 @@ unsigned int startNonBlockingBatch(void *rulesBinding,
     unsigned int result = RULES_OK;
     binding *currentBinding = (binding*)rulesBinding;
     redisContext *reContext = currentBinding->reContext;
-
+    
+    sds newbuf = sdsempty();
     for (unsigned int i = 0; i < commandCount; ++i) {
-        sds newbuf;
-        newbuf = sdscatlen(reContext->obuf, commands[i], strlen(commands[i]));
+        newbuf = sdscatlen(newbuf, commands[i], strlen(commands[i]));
         if (newbuf == NULL) {
             return ERR_OUT_OF_MEMORY;
         }
 
-        reContext->obuf = newbuf;
         free(commands[i]);
     }
 
+    reContext->obuf = newbuf;
     int wdone = 0;
     do {
         if (redisBufferWrite(reContext, &wdone) == REDIS_ERR) {
-            printf("error %u %s\n", reContext->err, reContext->errstr);
+            printf("start non blocking batch error %u %s\n", reContext->err, reContext->errstr);
             return ERR_REDIS_ERROR;
         }
     } while (!wdone);
@@ -2314,6 +2297,22 @@ unsigned int startNonBlockingBatch(void *rulesBinding,
     return result;
 }
 
+static unsigned int tryGetReply(redisContext *reContext, 
+                                redisReply **reply) {
+
+    if (redisGetReply(reContext, (void**)reply) != REDIS_OK) {
+        printf("getReply err %d, %d, %s\n", reContext->err, errno, reContext->errstr);
+        if (redisReconnect(reContext) != REDIS_OK) {
+            printf("reconnect err %d, %d, %s\n", reContext->err, errno, reContext->errstr);
+            return ERR_REDIS_ERROR;
+        }
+
+        return ERR_TRY_AGAIN;
+    }
+
+    return RULES_OK;
+}
+
 unsigned int completeNonBlockingBatch(void *rulesBinding,
                                       unsigned int replyCount) {
     if (replyCount == 0) {
@@ -2325,12 +2324,12 @@ unsigned int completeNonBlockingBatch(void *rulesBinding,
     redisContext *reContext = currentBinding->reContext;
     redisReply *reply;
     for (unsigned int i = 0; i < replyCount; ++i) {
-        result = redisGetReply(reContext, (void**)&reply);
-        if (result != REDIS_OK) {
-            result = ERR_REDIS_ERROR;
+        result = tryGetReply(reContext, &reply);
+        if (result != RULES_OK) {
+            return result;
         } else {
             if (reply->type == REDIS_REPLY_ERROR) {
-                printf("error %d %s\n", i, reply->str);
+                printf("complete non blocking batch error %d %s\n", i, reply->str);
                 result = ERR_REDIS_ERROR;
             }
 
@@ -2364,22 +2363,22 @@ unsigned int executeBatchWithReply(void *rulesBinding,
         *lastReply = NULL;
     }
 
+    sds newbuf = sdsempty();
     for (unsigned int i = 0; i < commandCount; ++i) {
-        sds newbuf;
-        newbuf = sdscatlen(reContext->obuf, commands[i], strlen(commands[i]));
+        newbuf = sdscatlen(newbuf, commands[i], strlen(commands[i]));
         if (newbuf == NULL) {
             return ERR_OUT_OF_MEMORY;
         }
 
-        reContext->obuf = newbuf;
         free(commands[i]);
     }
 
+    reContext->obuf = newbuf;
     redisReply *reply;
     for (unsigned int i = 0; i < replyCount; ++i) {
-        result = redisGetReply(reContext, (void**)&reply);
-        if (result != REDIS_OK) {
-            result = ERR_REDIS_ERROR;
+        result = tryGetReply(reContext, &reply);
+        if (result != RULES_OK) {
+            return result;
         } else {
             if (reply->type == REDIS_REPLY_ERROR) {
                 printf("%s\n", reply->str);
@@ -2417,12 +2416,13 @@ unsigned int removeMessage(void *rulesBinding, char *sid, char *mid) {
     }
 
     redisReply *reply;
-    result = redisGetReply(reContext, (void**)&reply);
-    if (result != REDIS_OK) {
-        return ERR_REDIS_ERROR;
+    result = tryGetReply(reContext, &reply);
+    if (result != RULES_OK) {
+        return result;
     }
 
     if (reply->type == REDIS_REPLY_ERROR) {
+        printf("removeMessage err string %s\n", reply->str);
         freeReplyObject(reply);
         return ERR_REDIS_ERROR;
     }
@@ -2442,19 +2442,19 @@ unsigned int peekAction(ruleset *tree, void **bindingContext, redisReply **reply
         int result = redisAppendCommand(reContext, 
                                         "evalsha %s 0 %d %ld", 
                                         currentBinding->peekActionHash, 
-                                        60,
+                                        currentTime + 15,
                                         currentTime); 
         if (result != REDIS_OK) {
             continue;
         }
 
-        result = redisGetReply(reContext, (void**)reply);
-        if (result != REDIS_OK) {
-            return ERR_REDIS_ERROR;
+        result = tryGetReply(reContext, reply);
+        if (result != RULES_OK) {
+            return result;
         }
 
         if ((*reply)->type == REDIS_REPLY_ERROR) {
-            printf("%s\n", (*reply)->str);
+            printf("peekAction err string %s\n", (*reply)->str);
             freeReplyObject(*reply);
             return ERR_REDIS_ERROR;
         }
@@ -2486,12 +2486,13 @@ unsigned int peekTimers(ruleset *tree, void **bindingContext, redisReply **reply
             continue;
         }
 
-        result = redisGetReply(reContext, (void**)reply);
-        if (result != REDIS_OK) {
-            return ERR_REDIS_ERROR;
+        result = tryGetReply(reContext, reply);
+        if (result != RULES_OK) {
+            return result;
         }
 
         if ((*reply)->type == REDIS_REPLY_ERROR) {
+            printf("peekTimers err string %s\n", (*reply)->str);
             freeReplyObject(*reply);
             return ERR_REDIS_ERROR;
         }
@@ -2522,12 +2523,71 @@ unsigned int registerTimer(void *rulesBinding, unsigned int duration, char *time
     }
     
     redisReply *reply;
-    result = redisGetReply(reContext, (void**)&reply);
+    result = tryGetReply(reContext, &reply);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    if (reply->type == REDIS_REPLY_ERROR) {
+        printf("registerTimer err string %s\n", reply->str);
+        freeReplyObject(reply);
+        return ERR_REDIS_ERROR;
+    }
+
+    freeReplyObject(reply);    
+    return RULES_OK;
+}
+
+unsigned int removeTimer(void *rulesBinding, char *timer) {
+    binding *currentBinding = (binding*)rulesBinding;
+    redisContext *reContext = currentBinding->reContext;   
+    
+    int result = redisAppendCommand(reContext, 
+                                    "zrem %s %s", 
+                                    currentBinding->timersSortedset,
+                                    timer);
     if (result != REDIS_OK) {
         return ERR_REDIS_ERROR;
     }
+    
+    redisReply *reply;
+    result = tryGetReply(reContext, &reply);
+    if (result != RULES_OK) {
+        return result;
+    }
 
     if (reply->type == REDIS_REPLY_ERROR) {
+        printf("deleteTimer err string %s\n", reply->str);
+        freeReplyObject(reply);
+        return ERR_REDIS_ERROR;
+    }
+
+    freeReplyObject(reply);    
+    return RULES_OK;
+}
+
+unsigned int registerMessage(void *rulesBinding, char *destination, char *message) {
+    binding *currentBinding = (binding*)rulesBinding;
+    redisContext *reContext = currentBinding->reContext;   
+    time_t currentTime = time(NULL);
+
+    int result = redisAppendCommand(reContext, 
+                                    "zadd %s!t %ld %s", 
+                                    destination, 
+                                    currentTime, 
+                                    message);
+    if (result != REDIS_OK) {
+        return ERR_REDIS_ERROR;
+    }
+    
+    redisReply *reply;
+    result = tryGetReply(reContext, &reply);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    if (reply->type == REDIS_REPLY_ERROR) {
+        printf("registerMessage err string %s\n", reply->str);
         freeReplyObject(reply);
         return ERR_REDIS_ERROR;
     }
@@ -2548,9 +2608,9 @@ unsigned int getSession(void *rulesBinding, char *sid, char **state) {
     }
 
     redisReply *reply;
-    result = redisGetReply(reContext, (void**)&reply);
-    if (result != REDIS_OK) {
-        return ERR_REDIS_ERROR;
+    result = tryGetReply(reContext, &reply);
+    if (result != RULES_OK) {
+        return result;
     }
 
     if (reply->type == REDIS_REPLY_ERROR) {
@@ -2563,7 +2623,7 @@ unsigned int getSession(void *rulesBinding, char *sid, char **state) {
         return ERR_NEW_SESSION;
     }
 
-    *state = malloc(strlen(reply->str) * sizeof(char));
+    *state = malloc((strlen(reply->str) + 1) * sizeof(char));
     if (!*state) {
         return ERR_OUT_OF_MEMORY;
     }
@@ -2572,4 +2632,32 @@ unsigned int getSession(void *rulesBinding, char *sid, char **state) {
     return REDIS_OK;
 }
 
+unsigned int updateAction(void *rulesBinding, char *sid) {
+    binding *currentBinding = (binding*)rulesBinding;
+    redisContext *reContext = currentBinding->reContext;   
+    time_t currentTime = time(NULL);
 
+    int result = redisAppendCommand(reContext, 
+                                    "evalsha %s 0 %s %ld", 
+                                    currentBinding->updateActionHash,
+                                    sid,
+                                    currentTime + 15); 
+    if (result != REDIS_OK) {
+        return ERR_REDIS_ERROR;
+    }
+    
+    redisReply *reply;
+    result = tryGetReply(reContext, &reply);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    if (reply->type == REDIS_REPLY_ERROR) {
+        printf("updateAction err string %s\n", reply->str);
+        freeReplyObject(reply);
+        return ERR_REDIS_ERROR;
+    }
+
+    freeReplyObject(reply);    
+    return RULES_OK;
+}