durable_rules 0.34.27 → 0.34.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c8271032dff0a76d7a23894c8feac51fd816be8f
-  data.tar.gz: 565c32ae6735f76c0e732ebd28fc63fec5959ef3
+  metadata.gz: 444692ec85550db95da9c6f15a8a4a28a5595327
+  data.tar.gz: f5613ee7347ce15f9f155a0819ff78463a842d06
 SHA512:
-  metadata.gz: 9bf826e66598b81e9de27aa890957132dd63cd3687ca46e9fe78c2b2e4dac178fc026173f4fae4ed73d285484c3b1cb6d65ed649ee32f24fe43b13093ef64471
-  data.tar.gz: ec3ccd64ea46ec1ead3bda34a917d0865661c8aff9a245547ec8d03ac220907a160d55fea4464692670c131bff130411308b68a7a073bbd7a105d7b39fd6c2cb
+  metadata.gz: 00fb2a9657488183693516eae86078b46c22c1639c9c684c605e44a9c73b6a04d09581f116f637a9d8ce8b21c5931f4fbd20df0f40f90c1bf46a8280521e5362
+  data.tar.gz: 2032f03a299f12291099f33f1adec895ed3f67aec3a0b0e14ec1bf90b8f9bc32ad2b340ca140ce403e3b4f5d3fdf66002efc57e128af7a43c8a620a8dcd91739

data/librb/durable.rb

@@ -141,6 +141,10 @@ module Durable
       return Expression.new(@name, @left).matches(other)
     end
 
+    def imatches(other)
+      return Expression.new(@name, @left).imatches(other)
+    end
+
     def ref_id(sid)
       Arithmetic.new @name, @left, sid
     end
@@ -251,6 +255,12 @@ module Durable
       self
     end
 
+    def imatches(other)
+      @__op = :$imt
+      @right = other
+      self
+    end
+
     def -@
       @__op = :$nex
       @right = 1
@@ -424,10 +434,6 @@ module Durable
       {:pri => value}
     end
 
-    def span(value)
-      {:span => value}
-    end
-
     def cap(value)
       {:cap => value}
     end
@@ -482,10 +488,6 @@ module Durable
         rule["pri"] = options[:pri]
       end
 
-      if options.key? :span
-        rule["span"] = options[:span]
-      end
-
       if options.key? :cap
         rule["cap"] = options[:cap]
       end

data/librb/engine.rb

@@ -124,29 +124,38 @@ module Engine
       @_queues[ruleset_name]
     end
 
-    def start_timer(timer_name, duration, timer_id = nil)
-      if !timer_id
-        timer_id = timer_name
+    def start_timer(timer_name, duration, manual_reset = false)
+      if manual_reset
+        manual_reset = 1
+      else
+        manual_reset = 0
       end
 
-      if @_timers.key? timer_id
-        raise ArgumentError, "Timer with id #{timer_id} already added"
+      if @_timers.key? timer_name
+        raise ArgumentError, "Timer with name #{timer_name} already added"
       else
-        timer = {:sid => @s.sid, :id => timer_id, :$t => timer_name}
-        @_timers[timer_id] = [timer, duration]
+        timer = {:sid => @s.sid, :$t => timer_name}
+        @_timers[timer_id] = [timer, duration, manual_reset]
       end
     end
 
-    def cancel_timer(timer_name, timer_id = nil)
-      if !timer_id
-        timer_id = timer_name
+    def cancel_timer(timer_name)
+      if @_cancelled_timers.key? timer_name
+        raise ArgumentError, "Timer with id #{timer_name} already cancelled"
+      else
+        @_cancelled_timers[timer_name] = true
       end
+    end
 
-      if @_cancelled_timers.key? timer_id
-        raise ArgumentError, "Timer with id #{timer_id} already cancelled"
+    def reset_timer(timer_name)
+      if @m.kind_of? Hash 
+        retract_timer timer_name, @m
       else
-        timer = {:sid => @s.sid, :id => timer_id, :$t => timer_name}
-        @_cancelled_timers[timer_id] = timer
+        for m in @m do
+          return true if retract_timer(timer_name, m)
+        end
+
+        return false
       end
     end
 
@@ -214,6 +223,22 @@ module Engine
 
     private
 
+    def retract_timer(timer_name, message) 
+      if ((message.key? :$t) && (message[:$t] == timer_name)) ||
+         ((message.key? '$t') && (message['$t'] == timer_name))
+         retract(message)
+         return true
+      end
+
+      for property_name, property_value in message do
+        if (property_value.kind_of? Hash) && retract_timer(timer_name, property_value)
+          return true
+        end
+      end
+
+      return false
+    end
+
     def handle_property(name, value=nil)
       name = name.to_s
       if name.end_with? '?'
@@ -369,11 +394,10 @@ module Engine
             end
           end
 
-          id = rand(1000000000)
           if assert_state
-            c.assert(:label => to_state, :chart => 1, :id => id)
+            c.assert(:label => to_state, :chart => 1)
           else
-            c.post(:label => to_state, :chart => 1, :id => id)
+            c.post(:label => to_state, :chart => 1)
           end
         end
       }
@@ -453,12 +477,12 @@ module Engine
       Rules.start_assert_events @handle, JSON.generate(messages)
     end
 
-    def start_timer(sid, timer, timer_duration)
-      Rules.start_timer @handle, sid.to_s, timer_duration, JSON.generate(timer)
+    def start_timer(sid, timer, timer_duration, manual_reset)
+      Rules.start_timer @handle, sid.to_s, timer_duration, manual_reset, JSON.generate(timer)
     end
 
-    def cancel_timer(sid, timer)
-      Rules.cancel_timer @handle, sid.to_s, JSON.generate(timer)
+    def cancel_timer(sid, timer_name)
+      Rules.cancel_timer @handle, sid.to_s, timer_name.to_s
     end
 
     def assert_fact(fact)
@@ -608,12 +632,12 @@ module Engine
             complete.call e, true
           else
             begin
-              for timer_id, timer in c._cancelled_timers do
-                cancel_timer c.s.sid, timer
+              for timer_name, timer_value in c._cancelled_timers do
+                cancel_timer c.s.sid, timer_name
               end
 
-              for timer_id, timer_duration in c._timers do
-                start_timer c.s.sid, timer_duration[0], timer_duration[1]
+              for timer_id, timer_tuple in c._timers do
+                start_timer c.s.sid, timer_tuple[0], timer_tuple[1], timer_tuple[2]
               end
 
               for ruleset_name, q in c._queues do
@@ -752,8 +776,7 @@ module Engine
           if ((trigger.key? :to) && (trigger[:to] == state_name)) ||
               ((trigger.key? "to") && (trigger["to"] == state_name)) ||
               (trigger.key? :count) || (trigger.key? "count") ||
-              (trigger.key? :cap) || (trigger.key? "cap") ||
-              (trigger.key? :span) || (trigger.key? "span")
+              (trigger.key? :cap) || (trigger.key? "cap") 
             reflexive_states[qualified_name] = true
           end
         end
@@ -807,12 +830,6 @@ module Engine
               rule[:count] = trigger["count"]
             end
 
-            if trigger.key? :span
-              rule[:span] = trigger[:span]
-            elsif trigger.key? "span"
-              rule[:span] = trigger["span"]
-            end
-
             if trigger.key? :cap
               rule[:cap] = trigger[:cap]
             elsif trigger.key? "cap"
@@ -936,8 +953,7 @@ module Engine
             for transition_name, transition in stage_to do
               if (transition_name == stage_name) ||
                   (transition.key? :count) || (transition.key? "count") ||
-                  (transition.key? :cap) || (transition.key? "cap") ||
-                  (transition.key? :span) || (transition.key? "span")
+                  (transition.key? :cap) || (transition.key? "cap")
                 reflexive_stages[stage_name] = true
               end
             end
@@ -1002,12 +1018,6 @@ module Engine
                 rule[:count] = transition["count"]
               end
 
-              if transition.key? :span
-                rule[:span] = transition[:span]
-              elsif transition.key? "span"
-                rule[:span] = transition["span"]
-              end
-
               if transition.key? :cap
                 rule[:cap] = transition[:cap]
               elsif transition.key? "cap"

data/librb/interface.rb

@@ -77,7 +77,7 @@ module Interface
       end
     end
 
-    post "/:ruleset_name/fact/:sid" do
+    post "/:ruleset_name/facts/:sid" do
       begin
         request.body.rewind
         message = JSON.parse request.body.read

data/src/rules/events.c

@@ -39,6 +39,7 @@
 #define OP_STRING_STRING 0x0101
 #define OP_STRING_NIL 0x0107
 #define OP_STRING_REGEX 0x010C
+#define OP_STRING_IREGEX 0x010D
 #define OP_NIL_BOOL 0x0704
 #define OP_NIL_INT 0x0702
 #define OP_NIL_DOUBLE 0x0703
@@ -885,9 +886,11 @@ static unsigned int isMatch(ruleset *tree,
 
             break;
         case OP_STRING_REGEX:
+        case OP_STRING_IREGEX:
             *propertyMatch = evaluateRegex(tree,
                                            message + currentProperty->valueOffset, 
                                            currentProperty->valueLength, 
+                                           (type == OP_STRING_REGEX) ? 0 : 1,
                                            currentAlpha->right.value.regex.vocabularyLength,
                                            currentAlpha->right.value.regex.statesLength,
                                            currentAlpha->right.value.regex.stateMachineOffset);
@@ -1878,7 +1881,7 @@ unsigned int queueMessage(void *handle, unsigned int queueAction, char *sid, cha
     return registerMessage(rulesBinding, queueAction, destination, message);
 }
 
-unsigned int startTimer(void *handle, char *sid, unsigned int duration, char *timer) {
+unsigned int startTimer(void *handle, char *sid, unsigned int duration, char manualReset, char *timer) {
     void *rulesBinding;
     if (!sid) {
         sid = "0";
@@ -1889,10 +1892,10 @@ unsigned int startTimer(void *handle, char *sid, unsigned int duration, char *ti
         return result;
     }
 
-    return registerTimer(rulesBinding, duration, timer);
+    return registerTimer(rulesBinding, duration, manualReset, timer);
 }
 
-unsigned int cancelTimer(void *handle, char *sid, char *timer) {
+unsigned int cancelTimer(void *handle, char *sid, char *timerName) {
     void *rulesBinding;
     if (!sid) {
         sid = "0";
@@ -1903,7 +1906,7 @@ unsigned int cancelTimer(void *handle, char *sid, char *timer) {
         return result;
     }
 
-    return removeTimer(rulesBinding, timer);
+    return removeTimer(rulesBinding, timerName);
 }
 
 unsigned int renewActionLease(void *handle, char *sid) {

data/src/rules/json.h

@@ -15,6 +15,7 @@
 #define JSON_STATE_IDIOM 0x0A
 #define JSON_EVENT_IDIOM 0x0B
 #define JSON_REGEX 0x0C
+#define JSON_IREGEX 0x0D
 
 unsigned int readNextName(char *start, char **first, char **last, unsigned int *hash);
 unsigned int readNextValue(char *start, char **first, char **last, unsigned char *type);

data/src/rules/net.c

@@ -393,16 +393,8 @@ static unsigned int loadRemoveActionCommand(ruleset *tree, binding *rulesBinding
 "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"
-"    if raw_count ~= \"single\" then\n"
-"        count = tonumber(raw_count)\n"
-"    end\n"
-"    if count == 0 then\n"
-"        local packed_frame = redis.call(\"lpop\", rule_action_key)\n"
-"        while packed_frame ~= \"0\" do\n"
-"            packed_frame = redis.call(\"lpop\", rule_action_key)\n"
-"        end\n"
-"    else\n"
+"    if raw_count then"
+"        local count = tonumber(string.sub(raw_count, 3))\n"
 "        for i = 0, count - 1, 1 do\n"
 "            local packed_frame = redis.call(\"rpop\", rule_action_key)\n"
 "        end\n"
@@ -439,12 +431,10 @@ static unsigned int loadTimerCommand(ruleset *tree, binding *rulesBinding) {
 "local timestamp = tonumber(ARGV[1])\n"
 "local res = redis.call(\"zrangebyscore\", timer_key, 0, timestamp, \"limit\", 0, 50)\n"
 "if #res > 0 then\n"
-"  for i = 0, #res, 1 do\n"
-"    if res[i] then\n"
-"      redis.call(\"zincrby\", timer_key, 10, tostring(res[i]))\n"
+"    for i = 1, #res, 1 do\n"
+"        redis.call(\"zincrby\", timer_key, 10, tostring(res[i]))\n"
 "    end\n"
-"  end\n"
-"  return res\n"
+"    return res\n"
 "end\n"
 "return 0\n", name)  == -1) {
         return ERR_OUT_OF_MEMORY;
@@ -460,6 +450,34 @@ static unsigned int loadTimerCommand(ruleset *tree, binding *rulesBinding) {
     return RULES_OK;
 }
 
+static unsigned int loadRemoveTimerCommand(ruleset *tree, binding *rulesBinding) {
+    char *name = &tree->stringPool[tree->nameOffset];
+    redisContext *reContext = rulesBinding->reContext;
+    redisReply *reply;
+    char *lua = NULL;
+    if (asprintf(&lua,
+"local timer_key = \"%s!t\"\n"
+"local timer_name = ARGV[1]\n"
+"local res = redis.call(\"zrange\", timer_key, 0, -1)\n"
+"for i = 1, #res, 1 do\n"
+"    if string.find(res[i], \"\\\"%%$t\\\"%%s*:%%s*\\\"\" .. timer_name .. \"\\\"\") then\n"
+"        redis.call(\"zrem\", timer_key, res[i])\n"
+"    end\n"
+"end\n"
+"return 0\n", name)  == -1) {
+        return ERR_OUT_OF_MEMORY;
+    }
+
+    unsigned int result = redisAppendCommand(reContext, "SCRIPT LOAD %s", lua);
+    GET_REPLY(result, "loadRemoveTimerCommand", reply);
+
+    strncpy(rulesBinding->removeTimerHash, reply->str, 40);
+    rulesBinding->removeTimerHash[40] = '\0';
+    freeReplyObject(reply);
+    free(lua);
+    return RULES_OK;
+}
+
 static unsigned int loadUpdateActionCommand(ruleset *tree, binding *rulesBinding) {
     char *name = &tree->stringPool[tree->nameOffset];
     redisContext *reContext = rulesBinding->reContext;
@@ -559,6 +577,7 @@ static unsigned int loadDeleteSessionCommand(ruleset *tree, binding *rulesBindin
 "        redis.call(\"del\", all_keys[i])\n"
 "    end\n"
 "end\n"
+"redis.call(\"hdel\", \"%s!c\", sid)\n"
 "redis.call(\"hdel\", \"%s!s\", sid)\n"
 "redis.call(\"hdel\", \"%s!s!v\", sid)\n"
 "redis.call(\"zrem\", \"%s!a\", sid)\n"
@@ -569,6 +588,7 @@ static unsigned int loadDeleteSessionCommand(ruleset *tree, binding *rulesBindin
                 name,
                 name,
                 name,
+                name,
                 name, 
                 name,
                 name, 
@@ -1031,54 +1051,31 @@ static unsigned int loadPeekActionCommand(ruleset *tree, binding *rulesBinding)
 "local load_frame_from_rule = function(rule_action_key, raw_count, sid, max_score)\n"
 "    local frames = {}\n"
 "    local packed_frames = {}\n"
-"    local unwrap = true\n"
-"    local count = 1\n"
-"    local left = false\n"
-"    if raw_count ~= \"single\" then\n"
-"        count = tonumber(raw_count)\n"
-"        unwrap = false\n"
-"    end\n"
-"    if count == 0 then\n"
-"        left = true\n"
-"        local packed_frame = redis.call(\"lpop\", rule_action_key)\n"
-"        while packed_frame ~= \"0\" do\n"
+"    local count = tonumber(string.sub(raw_count, 3))\n"
+"    local window = false\n"
+"    if string.find(raw_count, \"$w\") == 1 then\n"
+"        window = true\n"
+"    end\n"
+"    for i = 0, count - 1, 1 do\n"
+"        local packed_frame = redis.call(\"rpop\", rule_action_key)\n"
+"        if not packed_frame then\n"
+"            break\n"
+"        else\n"
 "            local frame = review_frame(cmsgpack.unpack(packed_frame), rule_action_key, sid, max_score)\n"
 "            if frame then\n"
 "                table.insert(frames, frame)\n"
 "                table.insert(packed_frames, packed_frame)\n"
 "            end\n"
-"            packed_frame = redis.call(\"lpop\", rule_action_key)\n"
-"        end\n"
-"        if #packed_frames > 0 then\n"
-"            redis.call(\"lpush\", rule_action_key, 0)\n"
-"        end\n"
-"    else\n"
-"        while count > 0 do\n"
-"            local packed_frame = redis.call(\"rpop\", rule_action_key)\n"
-"            if not packed_frame then\n"
-"                break\n"
-"            else\n"
-"                local frame = review_frame(cmsgpack.unpack(packed_frame), rule_action_key, sid, max_score)\n"
-"                if frame then\n"
-"                    table.insert(frames, frame)\n"
-"                    table.insert(packed_frames, packed_frame)\n"
-"                    count = count - 1\n"
-"                end\n"
-"            end\n"
 "        end\n"
 "    end\n"
 "    for i = #packed_frames, 1, -1 do\n"
-"        if left then\n"
-"            redis.call(\"lpush\", rule_action_key, packed_frames[i])\n"
-"        else\n"
-"            redis.call(\"rpush\", rule_action_key, packed_frames[i])\n"
-"        end\n"
+"        redis.call(\"rpush\", rule_action_key, packed_frames[i])\n"
 "    end\n"
-"    if #packed_frames == 0 then\n"
+"    if #packed_frames == 0 or (window and (#packed_frames ~= count)) then\n"
 "        return nil, nil\n"
 "    end\n"
 "    local last_name = string.find(rule_action_key, \"!\") - 1\n"
-"    if unwrap then\n"
+"    if window and count == 1 then\n"
 "        return string.sub(rule_action_key, 1, last_name), frames[1]\n"
 "    else\n"
 "        return string.sub(rule_action_key, 1, last_name), frames\n"
@@ -1653,23 +1650,7 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
                 }
             }
 
-            if (currentNode->value.c.span > 0) {
-                oldLua = lua;
-                if (asprintf(&lua,
-"%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) {
-                    return ERR_OUT_OF_MEMORY;
-                }
-                free(oldLua);
-
-            } else if (currentNode->value.c.cap > 0) {
+            if (currentNode->value.c.cap > 0) {
                 oldLua = lua;
                 if (asprintf(&lua,
 "%sif toggle then\n"
@@ -1720,7 +1701,6 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "local actions_key = \"%s!a\"\n"
 "local state_key = \"%s!s\"\n"
 "local mid_count_hashset = \"%s!c\"\n"
-"local queue_action = false\n"
 "local facts_message_cache = {}\n"
 "local events_message_cache = {}\n"
 "local facts_mids_cache = {}\n"
@@ -1972,50 +1952,9 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "    end\n"
 "    return result\n"
 "end\n"
-"local process_key_with_span = function(message, span)\n"
-"    local index = directory[key]\n"
-"    local queue_lock = false\n"
-"    if index then\n"
-"        local last_score = redis.call(\"get\", results_key .. \"!d\")\n"
-"        if not last_score then\n"
-"            redis.call(\"set\", results_key .. \"!d\", score)\n"
-"        else\n"
-"            local new_score = last_score + span\n"
-"            if score > new_score then\n"
-"                redis.call(\"rpush\", results_key, 0)\n"
-"                redis.call(\"rpush\", actions_key .. \"!\" .. sid, results_key)\n"
-"                redis.call(\"rpush\", actions_key .. \"!\" .. sid, 0)\n"
-"                local span_count, span_remain = math.modf((score - new_score) / span)\n"
-"                last_score = new_score + span_count * span\n"
-"                redis.call(\"set\", results_key .. \"!d\", last_score)\n"
-"                queue_lock = true\n"
-"            end\n"    
-"        end\n"
-"        local count = 0\n"
-"        if not message then\n"
-"            if assert_fact == 0 then\n"
-"                count = process_inverse_event(message, index, keys[index] .. \"!e!\" .. sid, false)\n"
-"            else\n"
-"                count = process_inverse_event(message, index, keys[index] .. \"!f!\" .. sid, true)\n"
-"            end\n"
-"        else\n"
-"            if assert_fact == 0 then\n"
-"                count = process_event(message, index, keys[index] .. \"!e!\" .. sid, false)\n"
-"            else\n"
-"                count = process_event(message, index, keys[index] .. \"!f!\" .. sid, true)\n"
-"            end\n"
-"        end\n"
-"        if (count > 0) then\n"
-"            for i = 1, #results, 1 do\n"
-"                redis.call(\"rpush\", results_key, results[i])\n"
-"            end\n"
-"        end\n"
-"    end\n"
-"    return queue_lock\n"
-"end\n"
 "local process_key_with_cap = function(message, cap)\n"
 "    local index = directory[key]\n"
-"    local queue_lock = false\n"
+"    local result_recorded = false\n"
 "    if index then\n"
 "        local count = 0\n"
 "        if not message then\n"
@@ -2032,6 +1971,7 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "            end\n"
 "        end\n"
 "        if (count > 0) then\n"
+"            result_recorded = true\n"
 "            for i = #results, 1, -1 do\n"
 "                redis.call(\"lpush\", results_key, results[i])\n"
 "            end\n"
@@ -2041,23 +1981,25 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "            if new_count > 0 then\n"
 "                for i = 1, new_count, 1 do\n"
 "                    redis.call(\"rpush\", actions_key .. \"!\" .. sid, results_key)\n"
-"                    redis.call(\"rpush\", actions_key .. \"!\" .. sid, cap)\n"
+"                    redis.call(\"rpush\", actions_key .. \"!\" .. sid, \"$c\" .. cap)\n"
 "                end\n"
 "            end\n"
 "            if new_remain > 0 then\n"
 "                redis.call(\"rpush\", actions_key .. \"!\" .. sid, results_key)\n"
-"                redis.call(\"rpush\", actions_key .. \"!\" .. sid, new_remain)\n"
+"                redis.call(\"rpush\", actions_key .. \"!\" .. sid, \"$c\" .. new_remain)\n"
 "            end\n"
-"            if new_count > 0 or new_remain > 0 then\n"
-"                queue_lock = true\n"
+"            if new_remain > 0 or new_count > 0 then\n"
+"                if not redis.call(\"zscore\", actions_key, sid) then\n"
+"                    redis.call(\"zadd\", actions_key , score, sid)\n"
+"                end\n"
 "            end\n"
 "        end\n"
 "    end\n"
-"    return queue_lock\n"
+"    return result_recorded\n"
 "end\n"
 "local process_key_with_window = function(message, window)\n"
 "    local index = directory[key]\n"
-"    local queue_lock = false\n"
+"    local result_recorded = false\n"
 "    if index then\n"
 "        local count = 0\n"
 "        if not message then\n"
@@ -2074,6 +2016,7 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "            end\n"
 "        end\n"
 "        if (count > 0) then\n"
+"            result_recorded = true\n"
 "            for i = #results, 1, -1 do\n"
 "                redis.call(\"lpush\", results_key, results[i])\n"
 "            end\n"
@@ -2085,17 +2028,15 @@ static unsigned int loadEvalMessageCommand(ruleset *tree, binding *rulesBinding)
 "            if diff > 0 then\n"
 "                for i = 0, diff - 1, 1 do\n"
 "                    redis.call(\"rpush\", actions_key .. \"!\" .. sid, results_key)\n"
-"                    if window == 1 then\n"
-"                        redis.call(\"rpush\", actions_key .. \"!\" .. sid, \"single\")\n"
-"                    else\n"
-"                        redis.call(\"rpush\", actions_key .. \"!\" .. sid, window)\n"
-"                    end\n"
+"                    redis.call(\"rpush\", actions_key .. \"!\" .. sid, \"$w\" .. window)\n"
+"                end\n"
+"                if not redis.call(\"zscore\", actions_key, sid) then\n"
+"                    redis.call(\"zadd\", actions_key , score, sid)\n"
 "                end\n"
-"                queue_lock = true\n"
 "             end\n"
 "        end\n"
 "    end\n"
-"    return queue_lock\n"
+"    return result_recorded\n"
 "end\n"
 "local process_message = function(message)\n"
 "    for index = 6, 5 + keys_count, 1 do\n"
@@ -2116,20 +2057,12 @@ static unsigned int loadEvalMessageCommand(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"
-"            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"
+"            local result_recorded = process_key(message, process_key_count)\n"
+"            if assert_fact == 0 and result_recorded then\n"
+"                return false\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"
@@ -2265,6 +2198,11 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
         return result;
     }
 
+    result = loadRemoveTimerCommand(tree, rulesBinding);
+    if (result != RULES_OK) {
+        return result;
+    }
+
     result = loadEvalMessageCommand(tree, rulesBinding);
     if (result != RULES_OK) {
         return result;
@@ -2949,28 +2887,37 @@ unsigned int peekTimers(ruleset *tree, void **bindingContext, redisReply **reply
     return ERR_NO_TIMERS_AVAILABLE;
 }
 
-unsigned int registerTimer(void *rulesBinding, unsigned int duration, char *timer) {
+unsigned int registerTimer(void *rulesBinding, unsigned int duration, char assert, char *timer) {
     binding *currentBinding = (binding*)rulesBinding;
     redisContext *reContext = currentBinding->reContext;   
     time_t currentTime = time(NULL);
 
-    int result = redisAppendCommand(reContext, 
+    int result = RULES_OK;
+    if (assert) {
+        result = redisAppendCommand(reContext, 
+                                    "zadd %s %ld a:%s", 
+                                    currentBinding->timersSortedset, 
+                                    currentTime + duration, 
+                                    timer);
+    } else {
+        result = redisAppendCommand(reContext, 
                                     "zadd %s %ld p:%s", 
                                     currentBinding->timersSortedset, 
                                     currentTime + duration, 
                                     timer);
+    } 
+
     VERIFY(result, "registerTimer");   
     return RULES_OK;
 }
 
-unsigned int removeTimer(void *rulesBinding, char *timer) {
+unsigned int removeTimer(void *rulesBinding, char *timerName) {
     binding *currentBinding = (binding*)rulesBinding;
     redisContext *reContext = currentBinding->reContext;   
-    
     int result = redisAppendCommand(reContext, 
-                                    "zrem %s p:%s", 
-                                    currentBinding->timersSortedset,
-                                    timer);
+                                    "evalsha %s 0 %s", 
+                                    currentBinding->removeTimerHash,
+                                    timerName); 
     VERIFY(result, "removeTimer");  
     return RULES_OK;
 }
@@ -2980,7 +2927,7 @@ unsigned int registerMessage(void *rulesBinding, unsigned int queueAction, char
     redisContext *reContext = currentBinding->reContext;   
     time_t currentTime = time(NULL);
 
-    int result = REDIS_OK;
+    int result = RULES_OK;
 
     switch (queueAction) {
         case QUEUE_ASSERT_FACT:

data/src/rules/net.h

@@ -30,6 +30,7 @@ typedef struct binding {
     functionHash removeActionHash;
     functionHash partitionHash;
     functionHash timersHash;
+    functionHash removeTimerHash;
     functionHash updateActionHash;
     functionHash deleteSessionHash;
     char *sessionHashset;
@@ -132,10 +133,11 @@ unsigned int peekTimers(ruleset *tree,
 
 unsigned int registerTimer(void *rulesBinding, 
                            unsigned int duration, 
+                           char assert,
                            char *timer);
 
 unsigned int removeTimer(void *rulesBinding, 
-                         char *timer);
+                         char *timerName);
 
 unsigned int registerMessage(void *rulesBinding, 
                              unsigned int queueAction,

data/src/rules/regex.c

@@ -2,6 +2,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <ctype.h>
 #include "rules.h"
 #include "rete.h"
 #include "regex.h"
@@ -899,6 +900,7 @@ static unsigned int ensureState(unsigned short *id,
                                 unsigned short stateListLength, 
                                 state **newState) {
     CREATE_STATE(id, newState);
+    unsigned short dotTransitions = 0;
     for (unsigned short i = 0; i < stateListLength; ++i) {
         state *targetState = list[i];
         for (unsigned short ii = 0; ii < targetState->transitionsLength; ++ii) {
@@ -907,6 +909,10 @@ static unsigned int ensureState(unsigned short *id,
             if (result != RULES_OK) {
                 return result;
             }
+
+            if (targetTransition->symbol == REGEX_DOT) {
+                ++dotTransitions;
+            }
         }
 
         if (targetState->isAccept) {
@@ -921,6 +927,19 @@ static unsigned int ensureState(unsigned short *id,
             return ERR_REGEX_CONFLICT;
         }        
     }
+
+    // when merging two states results in two or more dot transitions
+    // all specific transitions are cancelled, this allows for the
+    // first match to succeed.
+    if (dotTransitions > 1) {
+        for (unsigned short i = 0; i < (*newState)->transitionsLength; ++i) {
+            transition *currentTransition = &(*newState)->transitions[i];
+            if (currentTransition->symbol != REGEX_DOT) {
+                unlinkStates(*newState, currentTransition->next, currentTransition->symbol);
+            }
+        }
+    }
+
     return RULES_OK;
 }
 
@@ -1130,7 +1149,7 @@ static unsigned int transformToDFA(state *nfa,
 }
 
 static unsigned int expandDot(state *nfa, 
-                                   unsigned short *id) {
+                              unsigned short *id) {
 
     CREATE_HASHSET(state*);
     CREATE_QUEUE(state*);
@@ -1216,7 +1235,8 @@ static unsigned short getIndex(symbolEntry *symbolHashSet, unsigned short vocabu
 static unsigned int packGraph(state *start, 
                               void *stateMachine,
                               unsigned short vocabularyLength,
-                              unsigned short statesLength) {
+                              unsigned short statesLength,
+                              char caseInsensitive) {
     CREATE_QUEUE(state*);
     unsigned short visited[MAX_STATES] = {0};
     symbolEntry *symbolHashSet = (symbolEntry *)stateMachine;
@@ -1235,9 +1255,13 @@ static unsigned int packGraph(state *start,
 
         for (int i = 0; i < currentState->transitionsLength; ++ i) {
             transition *currentTransition = &currentState->transitions[i];
+            unsigned int currentTransitionSymbol = currentTransition->symbol;
+            if (caseInsensitive) {
+                currentTransitionSymbol = tolower(currentTransitionSymbol);
+            }
 
-            if (!getIndex(symbolHashSet, vocabularyLength, currentTransition->symbol)) {
-                setIndex(symbolHashSet, vocabularyLength, currentTransition->symbol, vocabularyNumber);
+            if (!getIndex(symbolHashSet, vocabularyLength, currentTransitionSymbol)) {
+                setIndex(symbolHashSet, vocabularyLength, currentTransitionSymbol, vocabularyNumber);
                 ++vocabularyNumber;
             }
 
@@ -1247,7 +1271,7 @@ static unsigned int packGraph(state *start,
                 ENQUEUE(currentTransition->next);
             }
 
-            unsigned short targetSymbolNumber = getIndex(symbolHashSet, vocabularyLength, currentTransition->symbol);
+            unsigned short targetSymbolNumber = getIndex(symbolHashSet, vocabularyLength, currentTransitionSymbol);
             stateTable[statesLength * (targetSymbolNumber - 1) + (targetStateNumber - 1)] = visited[currentTransition->next->id];
         }
 
@@ -1265,6 +1289,7 @@ unsigned int validateRegex(char *first,
 unsigned int compileRegex(void *tree, 
                           char *first, 
                           char *last, 
+                          char caseInsensitive,
                           unsigned short *vocabularyLength,
                           unsigned short *statesLength,
                           unsigned int *regexStateMachineOffset) {
@@ -1288,11 +1313,21 @@ unsigned int compileRegex(void *tree,
         return result;
     }
 
+#ifdef _PRINT
+    printf("*** DFA 1 ***\n");
+    printGraph(start);
+#endif
+
     result = expandDot(start, &id);
     if (result != RULES_OK) {
         return result;
     }
 
+#ifdef _PRINT
+    printf("*** DOT 1 ***\n");
+    printGraph(start);
+#endif
+
     result = transformToDFA(start, &id);
     if (result != RULES_OK) {
         return result;
@@ -1321,12 +1356,14 @@ unsigned int compileRegex(void *tree,
     return packGraph(start, 
                      newStateMachine, 
                      *vocabularyLength,
-                     *statesLength);
+                     *statesLength,
+                     caseInsensitive);
 }
 
 unsigned char evaluateRegex(void *tree,
                             char *first,
                             unsigned short length, 
+                            char caseInsensitive,
                             unsigned short vocabularyLength,
                             unsigned short statesLength,
                             unsigned int regexStateMachineOffset) {
@@ -1340,6 +1377,10 @@ unsigned char evaluateRegex(void *tree,
         if (utf8ToUnicode(&first, last, &unicodeSymbol) != REGEX_PARSE_OK) {
             return 0;
         } else {
+            if (caseInsensitive) {
+                unicodeSymbol = tolower(unicodeSymbol);
+            }
+
             unsigned short currentSymbol = getIndex(symbolHashSet, vocabularyLength, unicodeSymbol);
             if (!currentSymbol) {
                 currentSymbol = getIndex(symbolHashSet, vocabularyLength, REGEX_DOT);

data/src/rules/regex.h

@@ -8,13 +8,15 @@ unsigned int validateRegex(char *first,
 unsigned int compileRegex(void *tree, 
                           char *first, 
                           char *last, 
+                          char caseInsensitive,
                           unsigned short *vocabularyLength,
                           unsigned short *statesLength,
                           unsigned int *regexStateMachineOffset);
 
 unsigned char evaluateRegex(void *tree,
                             char *first,
-                            unsigned short length, 
+                            unsigned short length,
+                            char caseInsensitive, 
                             unsigned short vocabularyLength,
                             unsigned short statesLength,
                             unsigned int regexStateMachineOffset);

data/src/rules/rete.c

@@ -22,6 +22,7 @@
 #define HASH_EQ 193419647 // $eq
 #define HASH_NEQ 2087890573 // $neq
 #define HASH_MT 193419914 // $mt
+#define HASH_IMT 2087885395 // $imt
 #define HASH_EX 193419654 // $ex
 #define HASH_NEX 2087890580 // $nex
 #define HASH_OR 193419978 // $or
@@ -339,6 +340,7 @@ static unsigned int copyValue(ruleset *tree,
             right->value.b = leftb;
             break;
         case JSON_REGEX:
+        case JSON_IREGEX:
             leftLength = last - first;
             result = storeString(tree, first, &right->value.regex.stringOffset, leftLength);
             if (result != RULES_OK) {
@@ -348,6 +350,7 @@ static unsigned int copyValue(ruleset *tree,
             result = compileRegex(tree, 
                                   first, 
                                   last,
+                                  (type == JSON_REGEX) ? 0 : 1,
                                   &right->value.regex.vocabularyLength,
                                   &right->value.regex.statesLength,
                                   &right->value.regex.stateMachineOffset);
@@ -385,7 +388,7 @@ static unsigned char compareValue(ruleset *tree,
         case JSON_STRING:
             {
                 char *rightString;
-                if (right->type == JSON_REGEX) {
+                if (right->type == JSON_REGEX || right->type == JSON_IREGEX) {
                     rightString = &tree->stringPool[right->value.regex.stringOffset];
                 } else {
                     rightString = &tree->stringPool[right->value.stringOffset];
@@ -590,6 +593,9 @@ static unsigned int validateExpression(char *rule) {
         case HASH_MT:
             operator = OP_MT;
             break;
+        case HASH_IMT:
+            operator = OP_IMT;
+            break;
         case HASH_LT:
             operator = OP_LT;
             break;
@@ -640,7 +646,7 @@ static unsigned int validateExpression(char *rule) {
         return result;
     }
 
-    if (operator == OP_MT) {
+    if (operator == OP_MT || operator == OP_IMT) {
         if (type != JSON_STRING) {
             return ERR_UNEXPECTED_TYPE; 
         }  
@@ -1069,6 +1075,10 @@ static unsigned int findAlpha(ruleset *tree,
         type = JSON_REGEX;
     }
 
+    if (operator == OP_IMT) {
+        type = JSON_IREGEX;
+    }
+
     result = copyValue(tree, &newAlpha->value.a.right, first, last, idiomOffset, &ref, type);
     if (result != RULES_OK) {
         return result;
@@ -1155,6 +1165,9 @@ static unsigned int createAlpha(ruleset *tree,
         case HASH_MT:
             operator = OP_MT;
             break;
+        case HASH_IMT:
+            operator = OP_IMT;
+            break;
         case HASH_LT:
             operator = OP_LT;
             break;

data/src/rules/rete.h

@@ -21,6 +21,7 @@
 #define OP_TYPE 0x12
 #define OP_NOT 0x13
 #define OP_MT 0x14
+#define OP_IMT 0x15
 
 #define NODE_ALPHA 0
 #define NODE_BETA_CONNECTOR 1

data/src/rules/rules.h

@@ -164,11 +164,12 @@ unsigned int abandonAction(void *handle,
 unsigned int startTimer(void *handle, 
                         char *sid, 
                         unsigned int duration, 
+                        char manualReset,
                         char *timer);
 
 unsigned int cancelTimer(void *handle, 
                          char *sid, 
-                         char *timer);
+                         char *timerName);
 
 unsigned int queueMessage(void *handle,
                           unsigned int queueAction, 

data/src/rulesrb/rules.c

@@ -544,13 +544,14 @@ static VALUE rbAbandonAction(VALUE self, VALUE handle, VALUE actionHandle) {
     return Qnil;
 }
 
-static VALUE rbStartTimer(VALUE self, VALUE handle, VALUE sid, VALUE duration, VALUE timer) {
+static VALUE rbStartTimer(VALUE self, VALUE handle, VALUE sid, VALUE duration, VALUE manualReset, VALUE timer) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(sid, T_STRING);
     Check_Type(duration, T_FIXNUM);
+    Check_Type(manualReset, T_FIXNUM);
     Check_Type(timer, T_STRING);    
 
-    unsigned int result = startTimer((void *)FIX2LONG(handle), RSTRING_PTR(sid), FIX2UINT(duration), RSTRING_PTR(timer));
+    unsigned int result = startTimer((void *)FIX2LONG(handle), RSTRING_PTR(sid), FIX2UINT(duration), FIX2SHORT(manualReset), RSTRING_PTR(timer));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -562,12 +563,12 @@ static VALUE rbStartTimer(VALUE self, VALUE handle, VALUE sid, VALUE duration, V
     return Qnil;
 }
 
-static VALUE rbCancelTimer(VALUE self, VALUE handle, VALUE sid, VALUE timer) {
+static VALUE rbCancelTimer(VALUE self, VALUE handle, VALUE sid, VALUE timerName) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(sid, T_STRING);
-    Check_Type(timer, T_STRING);    
+    Check_Type(timerName, T_STRING);    
 
-    unsigned int result = cancelTimer((void *)FIX2LONG(handle), RSTRING_PTR(sid), RSTRING_PTR(timer));
+    unsigned int result = cancelTimer((void *)FIX2LONG(handle), RSTRING_PTR(sid), RSTRING_PTR(timerName));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
@@ -679,7 +680,7 @@ void Init_rules() {
     rb_define_singleton_method(rulesModule, "complete_action", rbCompleteAction, 3);
     rb_define_singleton_method(rulesModule, "complete_and_start_action", rbCompleteAndStartAction, 3);
     rb_define_singleton_method(rulesModule, "abandon_action", rbAbandonAction, 2);
-    rb_define_singleton_method(rulesModule, "start_timer", rbStartTimer, 4);
+    rb_define_singleton_method(rulesModule, "start_timer", rbStartTimer, 5);
     rb_define_singleton_method(rulesModule, "cancel_timer", rbCancelTimer, 3);
     rb_define_singleton_method(rulesModule, "assert_timers", rbAssertTimers, 1);
     rb_define_singleton_method(rulesModule, "get_state", rbGetState, 2);

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: durable_rules
 version: !ruby/object:Gem::Version
-  version: 0.34.27
+  version: 0.34.28
 platform: ruby
 authors:
 - Jesus Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-30 00:00:00.000000000 Z
+date: 2017-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake