durable_rules 0.34.10 → 0.34.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17af99e481ae4e0bcb1b2ebe209b6e5edc18fee9
-  data.tar.gz: cb8dd76e247553ece6ddc1e07b55c73185472a84
+  metadata.gz: 1a1c33ac9771e6fd5a65c237fa9ec44043ee2efa
+  data.tar.gz: 92da33c1378bccefc450cf31d0bbff11301fa2e8
 SHA512:
-  metadata.gz: 6e850df050e57f8d9c3a6afe9e95290dcda77a15822b653b0a4dd65dfc379ebf2f78fcf3139a84817250671031ef502ff3aa53c6ebb9d637d8c08ba972c7ab5f
-  data.tar.gz: 11c23e9dffe070addf470d6a5535dc4c964892c1674a047981c525009614ca5134af25b2553152885483542c3403285692da9fd013f32a17ccde565a1ef4c739
+  metadata.gz: e1557c00a12d9eff3c8d4d0b35c0e6efacf2928f2e1435eb873978e279af3a2f6f9f3b33d82bae98a2a10607469bf218ec942cc6a106f13cc5115d3c12ddb429
+  data.tar.gz: def1bedb13771e6f5546c5043933019cb36f1706293eb8afd79d97a05803dad5366765e085d87098aaa271a4d2e7b5834aeb261aed8bfad84f2b89f7b4893ec8

data/librb/durable.rb

@@ -178,7 +178,7 @@ module Durable
       @__name = nil
     end
     
-    def definition
+    def definition(parent_name=nil)
       new_definition = nil
       if @__op == :$or || @__op == :$and
         new_definition = {@__op => @definitions}
@@ -297,25 +297,33 @@ module Durable
       @expressions = expressions
     end
 
-    def definition
+    def definition(parent_name=nil)
       index = 0
       new_definition = []
       for expression in @expressions do
         if (expression.kind_of? Expression) && expression.__name
           expression_name = expression.__name
         elsif @expressions.length == 1 
-          expression_name = "m"
+          if parent_name
+            expression_name = "#{parent_name}.m"
+          else
+            expression_name = "m"
+          end
         else
-          expression_name = "m_#{index}"
+          if parent_name
+            expression_name = "#{parent_name}.m_#{index}"
+          else
+            expression_name = "m_#{index}"
+          end
         end
         if expression.__type == :$all
-          new_definition << {expression_name + "$all" => expression.definition()}
+          new_definition << {expression_name + "$all" => expression.definition(expression_name)}
         elsif expression.__type == :$any
-          new_definition << {expression_name + "$any" => expression.definition()}
+          new_definition << {expression_name + "$any" => expression.definition(expression_name)}
         elsif  expression.__type == :$not
           new_definition << {expression_name + "$not" => expression.definition()[0]["m"]}
         else
-          new_definition << {expression_name => expression.definition()}
+          new_definition << {expression_name => expression.definition(expression_name)}
         end
         index += 1
       end

data/librb/engine.rb

@@ -495,7 +495,11 @@ module Engine
     end
 
     def assert_state(state)
-      Rules.assert_state @handle, JSON.generate(state)
+      if state.key? :sid 
+        Rules.assert_state @handle, state[:sid].to_s, JSON.generate(state)
+      else
+        Rules.assert_state @handle, state["sid"].to_s, JSON.generate(state)
+      end
     end
 
     def get_state(sid)

data/src/rules/events.c

@@ -33,6 +33,7 @@
 #define OP_STRING_STRING 0x0101
 
 typedef struct actionContext {
+    unsigned long stateVersion;
     void *rulesBinding;
     redisReply *reply;
 } actionContext;
@@ -1029,6 +1030,7 @@ static unsigned int handleMessageCore(ruleset *tree,
     jsonProperty *sidProperty;
     int sidLength;
     char *storeCommand;
+    char *versionCommand;
     int result = getId(properties, sidIndex, &sidProperty, &sidLength);
     if (result != RULES_OK) {
         return result;
@@ -1064,17 +1066,20 @@ static unsigned int handleMessageCore(ruleset *tree,
             }
         }
 
-        if (*commandCount == MAX_COMMAND_COUNT) {
-            return ERR_MAX_COMMAND_COUNT;
-        }
-
-        result = formatStoreSession(*rulesBinding, sid, state, 0, &storeCommand);
+        result = formatStoreSession(*rulesBinding, sid, state, 0, &storeCommand, &versionCommand);
         if (result != RULES_OK) {
             return result;
         }
 
         commands[*commandCount] = storeCommand;
         ++*commandCount;
+
+        if (*commandCount == MAX_COMMAND_COUNT) {
+            return ERR_MAX_COMMAND_COUNT;
+        }
+
+        commands[*commandCount] = versionCommand;
+        ++*commandCount;
     }
     char *removeCommand = NULL;
     char *addKeys[MAX_ADD_COUNT];
@@ -1220,7 +1225,7 @@ static unsigned int handleMessageCore(ruleset *tree,
                 return ERR_MAX_COMMAND_COUNT;
             }
 
-            result = formatStoreSession(*rulesBinding, sid, newState, 1, &storeCommand);
+            result = formatStoreSession(*rulesBinding, sid, newState, 1, &storeCommand, &versionCommand);
             if (result != RULES_OK) {
                 return result;
             }
@@ -1228,6 +1233,13 @@ static unsigned int handleMessageCore(ruleset *tree,
             commands[*commandCount] = storeCommand;
             ++*commandCount;
 
+            if (*commandCount == MAX_COMMAND_COUNT) {
+                return ERR_MAX_COMMAND_COUNT;
+            }
+
+            commands[*commandCount] = versionCommand;
+            ++*commandCount;
+
             result = handleMessage(tree, 
                                    NULL,
                                    stateMessage,  
@@ -1362,7 +1374,8 @@ static unsigned int handleMessages(void *handle,
 }
 
 static unsigned int handleState(ruleset *tree, 
-                                char *state, 
+                                char *state,
+                                unsigned long stateVersion, 
                                 char **commands,
                                 unsigned int *commandCount,
                                 void **rulesBinding) {
@@ -1377,15 +1390,15 @@ static unsigned int handleState(ruleset *tree,
 
     char *stateMessagePostfix = state + 1;
 #ifdef _WIN32
-	char *stateMessage = (char *)_alloca(sizeof(char)*(35 + stateLength - 1));
+	char *stateMessage = (char *)_alloca(sizeof(char)*(40 + stateLength - 1));
 #else
-	char stateMessage[35 + stateLength - 1];
+	char stateMessage[40 + stateLength - 1];
 #endif
-    int randomMid = rand();
+    
 #ifdef _WIN32
-    sprintf_s(stateMessage, 35 + stateLength - 1, "{\"id\":\"$v-%d\", \"$s\":1, %s", randomMid, stateMessagePostfix);
+    sprintf_s(stateMessage, 40 + stateLength - 1, "{\"id\":\"$v-%016lu\", \"$s\":1, %s", stateVersion, stateMessagePostfix);
 #else
-	snprintf(stateMessage, 35 + stateLength - 1, "{\"id\":\"$v-%d\", \"$s\":1, %s", randomMid, stateMessagePostfix);
+	snprintf(stateMessage, 40 + stateLength - 1, "{\"id\":\"$v-%016lu\", \"$s\":1, %s", stateVersion, stateMessagePostfix);
 #endif
     unsigned int result = handleMessage(tree, 
                                         state,
@@ -1638,15 +1651,22 @@ unsigned int startRetractFacts(void *handle,
     return startHandleMessages(handle, messages, ACTION_REMOVE_FACT, rulesBinding, replyCount);
 }
 
-unsigned int assertState(void *handle, char *state) {
+unsigned int assertState(void *handle, char *sid, char *state) {
     char *commands[MAX_COMMAND_COUNT];
     unsigned int commandCount = 0;
     void *rulesBinding = NULL;
-    unsigned int result = handleState(handle, 
-                                      state, 
-                                      commands,
-                                      &commandCount,
-                                      &rulesBinding);
+    unsigned long stateVersion;
+    unsigned int result = getStateVersion(handle, sid, &stateVersion);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    result = handleState(handle, 
+                         state,
+                         stateVersion, 
+                         commands,
+                         &commandCount,
+                         &rulesBinding);
     if (result != RULES_OK && result != ERR_EVENT_NOT_HANDLED) {
         freeCommands(commands, commandCount);
         return result;
@@ -1693,13 +1713,14 @@ unsigned int startAction(void *handle,
         return result;
     }
 
-    *state = reply->element[1]->str;
-    *messages = reply->element[2]->str;
+    *state = reply->element[2]->str;
+    *messages = reply->element[3]->str;
     actionContext *context = malloc(sizeof(actionContext));
     if (!context) {
         return ERR_OUT_OF_MEMORY;
     }
     
+    context->stateVersion = reply->element[1]->integer;
     context->reply = reply;
     context->rulesBinding = rulesBinding;
     *actionHandle = context;
@@ -1715,8 +1736,10 @@ unsigned int startUpdateState(void *handle,
     char *commands[MAX_COMMAND_COUNT];
     unsigned int result = RULES_OK;
     unsigned int commandCount = 0;
+    unsigned long stateVersion = ((actionContext*)actionHandle)->stateVersion;
     result = handleState(handle, 
                          state, 
+                         stateVersion,
                          commands,
                          &commandCount,
                          rulesBinding);
@@ -1750,7 +1773,8 @@ unsigned int completeAction(void *handle,
 
     ++commandCount;
     result = handleState(handle, 
-                         state, 
+                         state,
+                         context->stateVersion, 
                          commands,
                          &commandCount,
                          &rulesBinding);
@@ -1823,7 +1847,8 @@ unsigned int completeAndStartAction(void *handle,
         return ERR_NO_ACTION_AVAILABLE;
     }
 
-    *messages = newReply->element[1]->str;
+    *messages = newReply->element[2]->str;
+    context->stateVersion = newReply->element[1]->integer;
     context->reply = newReply;
     return RULES_OK;
 }

data/src/rules/net.c

@@ -528,11 +528,13 @@ static unsigned int loadDeleteSessionCommand(ruleset *tree, binding *rulesBindin
 "    end\n"
 "end\n"
 "redis.call(\"hdel\", \"%s!s\", sid)\n"
+"redis.call(\"hdel\", \"%s!s!v\", sid)\n"
 "redis.call(\"zrem\", \"%s!a\", sid)\n"
 "redis.call(\"del\", \"%s!a!\" .. sid)\n"
 "redis.call(\"del\", \"%s!e!\" .. sid)\n"
 "redis.call(\"del\", \"%s!f!\" .. sid)\n"
 "redis.call(\"del\", \"%s!v!\" .. sid)\n%s",
+                name,
                 name,
                 name,
                 name, 
@@ -661,6 +663,10 @@ static unsigned int loadAddMessageCommand(ruleset *tree, binding *rulesBinding)
 "        else\n"
 "            message[ARGV[index]] = false\n"
 "        end\n"
+"    elseif ARGV[index + 2] == \"5\" then\n"
+"        message[ARGV[index]] = cjson.decode(ARGV[index + 1])\n"
+"    elseif ARGV[index + 2] == \"7\" then\n"
+"        message[ARGV[index]] = \"$null\"\n"
 "    end\n"
 "end\n"
 "local mid = message[\"id\"]\n"
@@ -763,8 +769,9 @@ static unsigned int loadPeekActionCommand(ruleset *tree, binding *rulesBinding)
                 for (unsigned int iii = 0; iii < currentJoin->expressionsLength; ++iii) {
                     unsigned int expressionOffset = tree->nextPool[currentJoin->expressionsOffset + iii];
                     expression *expr = &tree->expressionPool[expressionOffset];
-                    char *currentAlias = &tree->stringPool[expr->aliasOffset];
                     char *currentKey = &tree->stringPool[expr->nameOffset];
+                    char *currentAlias = &tree->stringPool[expr->aliasOffset];
+                
                     
                     if (iii == 0) {
                         if (expr->not) { 
@@ -1083,13 +1090,23 @@ static unsigned int loadPeekActionCommand(ruleset *tree, binding *rulesBinding)
 "    return sid, name, frame\n"
 "end\n"
 "local fixup_frame = function(frame)\n"
+"    local new_frame = {}\n"
 "    for message_name, message in pairs(frame) do\n"
-"        if message ~= \"$n\" then\n"
+"        if message_name == 1 then\n"
+"            return frame\n"
+"        end\n"
+"        local start\n"
+"        local name\n"
+"        local next\n"
+"        local new_message = {}\n"
+"        if message == \"$n\" then\n"
+"            new_message = message\n"
+"        else\n"
 "            for key, value in pairs(message) do\n"
-"                local start = 1\n"
-"                local sub_message = message\n"
-"                local name = key\n"
-"                local next = nil\n"
+"                local sub_message = new_message\n"
+"                start = 1\n"
+"                name = key\n"
+"                next = nil\n"
 "                repeat\n"
 "                    next = string.find(key, \"%%.\", start)\n"
 "                    if next then\n"
@@ -1106,12 +1123,36 @@ static unsigned int loadPeekActionCommand(ruleset *tree, binding *rulesBinding)
 "                        name = string.sub(key, start)\n"
 "                    end\n"
 "                until not next\n"
-"                message[key] = nil\n"
-"                sub_message[name] = value\n"
+"                if value == \"$null\" then\n"
+"                    sub_message[name] = cjson.null\n"
+"                else\n"
+"                   sub_message[name] = value\n"
+"                end\n"
 "            end\n"
 "        end\n"
+"        local sub_frame = new_frame\n"
+"        name = message_name\n"
+"        next = nil\n"
+"        start = 1\n"
+"        repeat\n"
+"            next = string.find(message_name, \"%%.\", start)\n"
+"            if next then\n"
+"                name = string.sub(message_name, start, next - 1)\n"
+"                if sub_frame[name] then\n"
+"                    sub_frame = sub_frame[name]\n"
+"                else\n"
+"                    local new_sub_frame = {}\n"
+"                    sub_frame[name] = new_sub_frame\n"
+"                    sub_frame = new_sub_frame\n"
+"                end\n"
+"                start = next + 1\n"
+"            else\n"
+"                name = string.sub(message_name, start)\n"
+"            end\n"
+"        until not next\n"
+"        sub_frame[name] = new_message\n"
 "    end\n"
-"    return frame\n"
+"    return new_frame\n"
 "end\n"
 "get_context = function(action_key)\n"
 "    if context_directory[action_key] then\n"
@@ -1128,11 +1169,12 @@ static unsigned int loadPeekActionCommand(ruleset *tree, binding *rulesBinding)
 "end\n"
 "if frame then\n"
 "    redis.call(\"zadd\", action_key, tonumber(ARGV[1]), new_sid)\n"
+"    local state_version = redis.call(\"hget\", state_key .. \"!v\", new_sid)\n"
 "    if #ARGV == 2 then\n"
 "        local state = redis.call(\"hget\", state_key, new_sid)\n"
-"        return {new_sid, state, cjson.encode({[action_name] = fixup_frame(frame)})}\n"
+"        return {new_sid, tonumber(state_version), state, cjson.encode({[action_name] = fixup_frame(frame)})}\n"
 "    else\n"
-"        return {new_sid, cjson.encode({[action_name] = fixup_frame(frame)})}\n"
+"        return {new_sid, tonumber(state_version), cjson.encode({[action_name] = fixup_frame(frame)})}\n"
 "    end\n"
 "end\n",
                 name,
@@ -1168,7 +1210,7 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
     char *lua = NULL;
     char *oldLua;
     
-    #ifdef _WIN32
+#ifdef _WIN32
     char *actionKey = (char *)_alloca(sizeof(char)*(nameLength + 3));
     sprintf_s(actionKey, nameLength + 3, "%s!a", name);
 #else
@@ -1206,6 +1248,7 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
                 oldLua = lua;
                 if (asprintf(&lua, 
 "%stoggle = false\n"
+"context_directory = {}\n"
 "context = {}\n"
 "reviewers = {}\n"
 "context[\"reviewers\"] = reviewers\n"
@@ -1236,9 +1279,10 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
                 for (unsigned int iii = 0; iii < currentJoin->expressionsLength; ++iii) {
                     unsigned int expressionOffset = tree->nextPool[currentJoin->expressionsOffset + iii];
                     expression *expr = &tree->expressionPool[expressionOffset];
-                    char *currentAlias = &tree->stringPool[expr->aliasOffset];
                     char *currentKey = &tree->stringPool[expr->nameOffset];
+                    char *currentAlias = &tree->stringPool[expr->aliasOffset];
                     char *nextKeyTest;
+
                     if (iii == (currentJoin->expressionsLength - 1)) {
                         nextKeyTest = (char*)calloc(1, sizeof(char));
                         if (!nextKeyTest) {
@@ -1384,6 +1428,7 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
                         char *test = NULL;
                         char *primaryKeyLua = NULL;
                         char *primaryFrameKeyLua = NULL;
+                        
                         unsigned int result = createTest(tree, expr, &test, &primaryKeyLua, &primaryFrameKeyLua);
                         if (result != RULES_OK) {
                             return result;
@@ -1569,6 +1614,9 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "%sif toggle then\n"
 "    context[\"process_key\"] = process_key_with_span\n"
 "    context[\"process_key_count\"] = %d\n"
+"    if not process_message(message) then\n"
+"        return\n"
+"    end\n"
 "end\n",
                                  lua,
                                  currentNode->value.c.span)  == -1) {
@@ -1582,6 +1630,9 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "%sif toggle then\n"
 "    context[\"process_key\"] = process_key_with_cap\n"
 "    context[\"process_key_count\"] = %d\n"
+"    if not process_message(message) then\n"
+"        return\n"
+"    end\n"
 "end\n",
                                  lua,
                                  currentNode->value.c.cap)  == -1) {
@@ -1595,6 +1646,9 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "%sif toggle then\n"
 "    context[\"process_key\"] = process_key_with_window\n"
 "    context[\"process_key_count\"] = %d\n"
+"    if not process_message(message) then\n"
+"        return\n"
+"    end\n"
 "end\n",
                                  lua,
                                  currentNode->value.c.count)  == -1) {
@@ -1998,6 +2052,41 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "    end\n"
 "    return queue_lock\n"
 "end\n"
+"local process_message = function(message)\n"
+"    for index = 6, 5 + keys_count, 1 do\n"
+"        results = {}\n"
+"        unpacked_results = {}\n"
+"        key = ARGV[index]\n"
+"        context = context_directory[key]\n"
+"        if context then\n"
+"        keys = context[\"keys\"]\n"
+"        reviewers = context[\"reviewers\"]\n"
+"        frame_packers = context[\"frame_packers\"]\n"
+"        frame_unpackers = context[\"frame_unpackers\"]\n"
+"        primary_message_keys = context[\"primary_message_keys\"]\n"
+"        primary_frame_keys = context[\"primary_frame_keys\"]\n"
+"        directory = context[\"directory\"]\n"
+"        results_key = context[\"results_key\"]\n"
+"        inverse_directory = context[\"inverse_directory\"]\n"
+"        expressions_count = context[\"expressions_count\"]\n"
+"        local process_key = context[\"process_key\"]\n"
+"        local process_key_count = context[\"process_key_count\"]\n"
+"        queue_action = process_key(message, process_key_count) or queue_action\n"
+"        if assert_fact == 0 and events_message_cache[tostring(message[\"id\"])] == false then\n"
+"            break\n"
+"        end\n"
+"        end\n"
+"    end\n"
+"    if queue_action then\n"
+"        if not redis.call(\"zscore\", actions_key, sid) then\n"
+"            redis.call(\"zadd\", actions_key , score, sid)\n"
+"        end\n"
+"        if assert_fact == 0 then\n"
+"            return false\n"
+"        end\n"
+"    end\n"
+"    return true\n"
+"end\n"
 "local message = nil\n"
 "if #ARGV > (6 + keys_count) then\n"
 "    message = {}\n"
@@ -2012,6 +2101,10 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "            else\n"
 "                message[ARGV[index]] = false\n"
 "            end\n"
+"        elseif ARGV[index + 2] == \"5\" then\n"
+"            message[ARGV[index]] = cjson.decode(ARGV[index + 1])\n"
+"        elseif ARGV[index + 2] == \"7\" then\n"
+"            message[ARGV[index]] = \"$null\"\n"
 "        end\n"
 "    end\n"
 "    if assert_fact == 1 then\n"
@@ -2032,33 +2125,7 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "for index = 6, 5 + keys_count, 1 do\n"
 "    input_keys[ARGV[index]] = true\n"
 "end\n"
-"%sfor index = 6, 5 + keys_count, 1 do\n"
-"    results = {}\n"
-"    unpacked_results = {}\n"
-"    key = ARGV[index]\n"
-"    context = context_directory[key]\n"
-"    keys = context[\"keys\"]\n"
-"    reviewers = context[\"reviewers\"]\n"
-"    frame_packers = context[\"frame_packers\"]\n"
-"    frame_unpackers = context[\"frame_unpackers\"]\n"
-"    primary_message_keys = context[\"primary_message_keys\"]\n"
-"    primary_frame_keys = context[\"primary_frame_keys\"]\n"
-"    directory = context[\"directory\"]\n"
-"    results_key = context[\"results_key\"]\n"
-"    inverse_directory = context[\"inverse_directory\"]\n"
-"    expressions_count = context[\"expressions_count\"]\n"
-"    local process_key = context[\"process_key\"]\n"
-"    local process_key_count = context[\"process_key_count\"]\n"
-"    queue_action = process_key(message, process_key_count) or queue_action\n"
-"    if assert_fact == 0 and events_message_cache[tostring(message[\"id\"])] == false then\n"
-"        break\n"
-"    end\n"
-"end\n"
-"if queue_action then\n"
-"    if not redis.call(\"zscore\", actions_key, sid) then\n"
-"        redis.call(\"zadd\", actions_key , score, sid)\n"
-"    end\n"
-"end\n",
+"%s\n",
                  name,
                  name,
                  name,
@@ -2493,22 +2560,40 @@ unsigned int formatStoreSession(void *rulesBinding,
                                 char *sid, 
                                 char *state,
                                 unsigned char tryExists, 
-                                char **command) {
+                                char **storeCommand,
+                                char **versionCommand) {
     binding *currentBinding = (binding*)rulesBinding;
 
     int result;
     if (tryExists) {
-        result = redisFormatCommand(command,
+        result = redisFormatCommand(storeCommand,
                                     "hsetnx %s %s %s", 
                                     currentBinding->sessionHashset, 
                                     sid, 
                                     state);
+        if (result == 0) {
+            return ERR_OUT_OF_MEMORY;
+        }
+
+        result = redisFormatCommand(versionCommand,
+                                    "hsetnx %s!v %s 0", 
+                                    currentBinding->sessionHashset, 
+                                    sid);
     } else {
-        result = redisFormatCommand(command,
+        result = redisFormatCommand(storeCommand,
                                     "hset %s %s %s", 
                                     currentBinding->sessionHashset, 
                                     sid, 
                                     state);
+
+        if (result == 0) {
+            return ERR_OUT_OF_MEMORY;
+        }
+
+        result = redisFormatCommand(versionCommand,
+                                    "hincrby %s!v %s 1", 
+                                    currentBinding->sessionHashset, 
+                                    sid);
     }
 
     if (result == 0) {
@@ -3028,6 +3113,38 @@ unsigned int getSession(void *rulesBinding, char *sid, char **state) {
     return REDIS_OK;
 }
 
+unsigned int getSessionVersion(void *rulesBinding, char *sid, unsigned long *stateVersion) {
+    binding *currentBinding = (binding*)rulesBinding;
+    redisContext *reContext = currentBinding->reContext; 
+    unsigned int result = redisAppendCommand(reContext, 
+                                             "hget %s!v %s", 
+                                             currentBinding->sessionHashset, 
+                                             sid);
+    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) {
+        freeReplyObject(reply);
+        return ERR_REDIS_ERROR;
+    }
+
+    if (reply->type != REDIS_REPLY_INTEGER) {
+        *stateVersion = 0;
+    } else {
+        *stateVersion = reply->integer;
+    }
+
+    freeReplyObject(reply); 
+    return REDIS_OK;
+}
+
 unsigned int deleteSession(void *rulesBinding, char *sid) {
     binding *currentBinding = (binding*)rulesBinding;
     redisContext *reContext = currentBinding->reContext; 

data/src/rules/net.h

@@ -74,7 +74,8 @@ unsigned int formatStoreSession(void *rulesBinding,
                                 char *sid, 
                                 char *state, 
                                 unsigned char tryExists,
-                                char **command);
+                                char **storeCommand,
+                                char **versionCommand);
 
 unsigned int formatStoreSessionFact(void *rulesBinding, 
                                     char *sid, 
@@ -148,6 +149,10 @@ unsigned int getSession(void *rulesBinding,
                         char *sid, 
                         char **state);
 
+unsigned int getSessionVersion(void *rulesBinding, 
+                               char *sid, 
+                               unsigned long *stateVersion);
+
 unsigned int deleteSession(void *rulesBinding, 
                            char *sid);
 

data/src/rules/rules.h

@@ -131,7 +131,8 @@ unsigned int startUpdateState(void *handle,
                               void **rulesBinding,
                               unsigned int *replyCount);
 
-unsigned int assertState(void *handle, 
+unsigned int assertState(void *handle,
+                         char *sid, 
                          char *state);
 
 unsigned int startAction(void *handle, 

data/src/rules/state.c

@@ -453,6 +453,17 @@ unsigned int getState(void *handle, char *sid, char **state) {
     return getSession(rulesBinding, sid, state);
 }
 
+unsigned int getStateVersion(void *handle, char *sid, unsigned long *stateVersion) {
+    void *rulesBinding = NULL;
+    unsigned int result = resolveBinding(handle, sid, &rulesBinding);
+    if (result != RULES_OK) {
+      return result;
+    }
+
+    return getSessionVersion(rulesBinding, sid, stateVersion);
+}
+
+
 unsigned int deleteState(void *handle, char *sid) {
     void *rulesBinding = NULL;
     unsigned int result = resolveBinding(handle, sid, &rulesBinding);

data/src/rules/state.h

@@ -57,3 +57,6 @@ unsigned int fetchStateProperty(void *tree,
                                 unsigned char ignoreStaleState,
                                 char **state,
                                 jsonProperty **property);
+unsigned int getStateVersion(void *handle, 
+                             char *sid, 
+                             unsigned long *stateVersion);

data/src/rulesrb/rules.c

@@ -420,11 +420,12 @@ static VALUE rbRetractFacts(VALUE self, VALUE handle, VALUE facts) {
     return Qnil;
 }
 
-static VALUE rbAssertState(VALUE self, VALUE handle, VALUE state) {
+static VALUE rbAssertState(VALUE self, VALUE handle, VALUE sid, VALUE state) {
     Check_Type(handle, T_FIXNUM);
+    Check_Type(sid, T_STRING);
     Check_Type(state, T_STRING);
 
-    unsigned int result = assertState((void *)FIX2LONG(handle), RSTRING_PTR(state));
+    unsigned int result = assertState((void *)FIX2LONG(handle), RSTRING_PTR(sid), RSTRING_PTR(state));
     if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
         return INT2FIX(result);    
     } else {
@@ -671,7 +672,7 @@ void Init_rules() {
     rb_define_singleton_method(rulesModule, "queue_retract_fact", rbQueueRetractFact, 4);
     rb_define_singleton_method(rulesModule, "start_retract_facts", rbStartRetractFacts, 2);
     rb_define_singleton_method(rulesModule, "retract_facts", rbRetractFacts, 2);
-    rb_define_singleton_method(rulesModule, "assert_state", rbAssertState, 2);
+    rb_define_singleton_method(rulesModule, "assert_state", rbAssertState, 3);
     rb_define_singleton_method(rulesModule, "start_update_state", rbStartUpdateState, 3);
     rb_define_singleton_method(rulesModule, "start_action", rbStartAction, 1);
     rb_define_singleton_method(rulesModule, "complete_action", rbCompleteAction, 3);

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: durable_rules
 version: !ruby/object:Gem::Version
-  version: 0.34.10
+  version: 0.34.11
 platform: ruby
 authors:
 - Jesus Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-06 00:00:00.000000000 Z
+date: 2016-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -129,7 +129,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.0.14.1
 signing_key: 
 specification_version: 4
 summary: for real time analytics (a Ruby Rules Engine)