durable_rules 0.34.01 → 0.34.02

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb52f7512b46132ca90ab9cb4038c7dcb5973dfe
-  data.tar.gz: 62eaa3495f4deb49bb499e4cd4c876b05857b50f
+  metadata.gz: d6180a0278ca667dd708b04c45359d7d205bb5ee
+  data.tar.gz: 77f98579d75d5a6ede0cf04de0cb030eb75227cd
 SHA512:
-  metadata.gz: 73013f0de7d4fb5eb3624a61a15fa6dd4d6d287a56d48de1877b48eacb5a7b646abc9f7f20ffd207a4ba945632c2a31ab4683759a684512f4fdd40da26436047
-  data.tar.gz: b5e83a8ce76c35b5e8e6c010b7f04c2bf135c8dd7de9641173db3f9a5e14fc53098a71b9412b30c10a879264d2a53a8d07cfc55b5119fe5284cff88960d3adb4
+  metadata.gz: 83a19d52b25b82a7369a679d5223b8e3dc2eb848b0c3a9cc4a75882f327f55434fc7a822bc9f2f91387977f8372daebbb19303cc6223516b67011229aebb172a
+  data.tar.gz: 0ec42e6ec72b8e569f632bcdb487787eb9692401c556071393ed2b62cccc46d4064f89d76b72f36c9567c2413eeb796fa03ecfc1cf9506493a5224c20d75bd09

data/librb/durable.rb

@@ -5,22 +5,27 @@ module Durable
   @@rulesets = {}
   @@start_blocks = []
 
-  def self.run(ruleset_definitions = nil, databases = [{:host => 'localhost', :port => 6379, :password => nil}], start = nil)
-    main_host = Engine::Host.new ruleset_definitions, databases
-    start.call main_host if start
-    main_host.start!
-    Interface::Application.set_host main_host
-    Interface::Application.run!
+  def self.create_queue(ruleset_name, database = {:host => 'localhost', :port => 6379, :password => nil}, state_cache_size = 1024)
+    Engine::Queue.new ruleset_name, database, state_cache_size
   end
 
-  def self.run_all(databases = [{:host => 'localhost', :port => 6379, :password => nil}])
-    main_host = Engine::Host.new @@rulesets, databases
+  def self.create_host(databases = [{:host => 'localhost', :port => 6379, :password => nil}], state_cache_size = 1024)
+    main_host = Engine::Host.new @@rulesets, databases, state_cache_size
     for block in @@start_blocks
       main_host.instance_exec main_host, &block
     end
     main_host.start!
+    main_host
+  end
+
+  def self.run_all(databases = [{:host => 'localhost', :port => 6379, :password => nil}], host_name = nil, port = nil, run = nil, state_cache_size = 1024)
+    main_host = self.create_host databases, state_cache_size
     Interface::Application.set_host main_host
-    Interface::Application.run!
+    if run
+      run(main_host, Interface::Application)
+    else
+      Interface::Application.run!
+    end
   end
 
   def self.ruleset(name, &block) 

data/librb/engine.rb

@@ -4,8 +4,43 @@ require_relative "../src/rulesrb/rules"
 
 module Engine
   @@timers = nil
+
+  class Closure_Queue
+    attr_reader :_queued_posts, :_queued_asserts, :_queued_retracts
+    
+    def initialize()
+      @_queued_posts = []
+      @_queued_asserts = []
+      @_queued_retracts = []
+    end
+
+    def post(message)
+      if message.kind_of? Content
+        message = message._d
+      end
+
+      @_queued_posts << message
+    end
+
+    def assert(message)
+      if message.kind_of? Content
+        message = message._d
+      end
+
+      @_queued_asserts << message
+    end
+
+    def retract(message)
+      if message.kind_of? Content
+        message = message._d
+      end
+
+      @_queued_retracts << message
+    end
+  end
+
   class Closure
-    attr_reader :host, :handle, :ruleset_name, :_timers, :_cancelled_timers, :_branches, :_messages, :_queued_messages, :_facts, :_retract
+    attr_reader :host, :handle, :ruleset_name, :_timers, :_cancelled_timers, :_branches, :_messages, :_queues, :_facts, :_retract
     attr_accessor :s
 
     def initialize(host, state, message, handle, ruleset_name)
@@ -16,7 +51,7 @@ module Engine
       @_timers = {}
       @_cancelled_timers = {}
       @_messages = {}
-      @_queued_messages = {}
+      @_queues = {}
       @_branches = {}
       @_facts = {}
       @_retract = {}
@@ -58,22 +93,12 @@ module Engine
       message_list << message
     end
 
-    def queue(ruleset_name, message)
-      if message.kind_of? Content
-        message = message._d
-      end
-
-      if !(message.key? :sid) && !(message.key? "sid")
-        message[:sid] = @s.sid
+    def get_queue(ruleset_name)
+      if !@_queues.key? ruleset_name
+        @_queues[ruleset_name] = Closure_Queue.new
       end
 
-      message_list = []
-      if @_queued_messages.key? ruleset_name
-        message_list = @_queued_messages[ruleset_name]
-      else
-        @_queued_messages[ruleset_name] = message_list
-      end
-      message_list << message
+      @_queues[ruleset_name]
     end
 
     def start_timer(timer_name, duration, timer_id = nil)
@@ -151,7 +176,7 @@ module Engine
     def renew_action_lease()
       if Time.now - @_start_time < 10000
         @_start_time = Time.now
-        @host.renew_action_lease(@ruleset_name, @s.sid)
+        @host.renew_action_lease @ruleset_name, @s.sid
       end
     end
 
@@ -289,7 +314,7 @@ module Engine
                 c.s.exception = "timeout expired"
                 complete.call nil
               else
-                c.renew_action_lease()
+                c.renew_action_lease
               end
             }
             Thread.new do
@@ -382,8 +407,8 @@ module Engine
       Rules.assert_event @handle, JSON.generate(message)
     end
 
-    def queue_event(sid, ruleset_name, message)
-      Rules.queue_event @handle, sid.to_s, ruleset_name.to_s, JSON.generate(message)
+    def queue_assert_event(sid, ruleset_name, message)
+      Rules.queue_assert_event @handle, sid.to_s, ruleset_name.to_s, JSON.generate(message)
     end
 
     def start_assert_event(message)
@@ -410,6 +435,10 @@ module Engine
       Rules.assert_fact @handle, JSON.generate(fact)
     end
 
+    def queue_assert_fact(sid, ruleset_name, message)
+      Rules.queue_assert_fact @handle, sid.to_s, ruleset_name.to_s, JSON.generate(message)
+    end
+
     def start_assert_fact(fact)
       return Rules.start_assert_fact @handle, JSON.generate(fact)
     end
@@ -426,6 +455,10 @@ module Engine
       Rules.retract_fact @handle, JSON.generate(fact)
     end
 
+    def queue_retract_fact(sid, ruleset_name, message)
+      Rules.queue_retract_fact @handle, sid.to_s, ruleset_name.to_s, JSON.generate(message)
+    end
+
     def start_retract_fact(fact)
       return Rules.start_retract_fact @handle, JSON.generate(fact)
     end
@@ -538,9 +571,20 @@ module Engine
                 start_timer c.s.sid, timer_duration[0], timer_duration[1]
               end
 
-              for ruleset_name, messages in c._queued_messages do
-                for message in messages do
-                  queue_event c.s.sid, ruleset_name, message  
+              for ruleset_name, q in c._queues do
+                for message in q._queued_posts do
+                  sid = (message.key? :sid) ? message[:sid]: message['sid']
+                  queue_assert_event sid.to_s, ruleset_name, message  
+                end
+
+                for message in q._queued_asserts do
+                  sid = (message.key? :sid) ? message[:sid]: message['sid']
+                  queue_assert_fact sid.to_s, ruleset_name, message  
+                end
+
+                for message in q._queued_retracts do
+                  sid = (message.key? :sid) ? message[:sid]: message['sid']
+                  queue_retract_fact sid.to_s, ruleset_name, message  
                 end
               end
 
@@ -1077,10 +1121,6 @@ module Engine
       return get_ruleset(ruleset_name).start_retract_facts facts
     end
 
-    def start_timer(ruleset_name, sid, timer_name, timer_duration)
-      get_ruleset(ruleset_name).start_timer sid, timer_name, timer_duration
-    end
-
     def patch_state(ruleset_name, state)
       get_ruleset(ruleset_name).assert_state state
     end
@@ -1145,4 +1185,36 @@ module Engine
 
   end
 
+  class Queue
+
+    def initialize(ruleset_name, database = {:host => 'localhost', :port => 6379, :password => nil}, state_cache_size = 1024)
+      @_ruleset_name = ruleset_name.to_s
+      @handle = Rules.create_client @_ruleset_name, state_cache_size
+      if database.kind_of? String
+        Rules.bind_ruleset @handle, database, 0, nil
+      else 
+        Rules.bind_ruleset @handle, database[:host], database[:port], database[:password] 
+      end
+    end
+        
+    def post(message)
+      sid = (message.key? :sid) ? message[:sid]: message['sid']
+      Rules.queue_assert_event @handle, sid.to_s, @_ruleset_name, JSON.generate(message)
+    end
+
+    def assert(message)
+      sid = (message.key? :sid) ? message[:sid]: message['sid']
+      Rules.queue_assert_fact @handle, sid.to_s, @_ruleset_name, JSON.generate(message)
+    end
+
+    def retract(message)
+      sid = (message.key? :sid) ? message[:sid]: message['sid']
+      Rules.queue_retract_fact @handle, sid.to_s, @_ruleset_name, JSON.generate(message)
+    end
+
+    def close()
+      Rules.delete_client @handle
+    end
+  end
+
 end

data/src/rules/events.c

@@ -1436,12 +1436,25 @@ static unsigned int handleTimers(void *handle,
             return result;
         }
 
+        unsigned int action;
+        switch (reply->element[i]->str[0]) {
+            case 'p':
+                action  = ACTION_ASSERT_EVENT;
+                break;
+            case 'a':
+                action  = ACTION_ASSERT_FACT;
+                break;
+            case 'r':
+                action  = ACTION_RETRACT_FACT;
+                break;
+        }
+
         commands[*commandCount] = command;
         ++*commandCount;
         result = handleMessage(handle, 
                                NULL,
-                               reply->element[i]->str, 
-                               ACTION_ASSERT_EVENT,
+                               reply->element[i]->str + 2, 
+                               action,
                                commands, 
                                commandCount, 
                                rulesBinding);
@@ -1847,14 +1860,14 @@ unsigned int abandonAction(void *handle, void *actionHandle) {
     return RULES_OK;
 }
 
-unsigned int queueMessage(void *handle, char *sid, char *destination, char *message) {
+unsigned int queueMessage(void *handle, unsigned int queueAction, char *sid, char *destination, char *message) {
     void *rulesBinding;
     unsigned int result = resolveBinding(handle, sid, &rulesBinding);
     if (result != RULES_OK) {
         return result;
     }
 
-    return registerMessage(rulesBinding, destination, message);
+    return registerMessage(rulesBinding, queueAction, destination, message);
 }
 
 unsigned int startTimer(void *handle, char *sid, unsigned int duration, char *timer) {

data/src/rules/net.c

@@ -1,12 +1,17 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <time.h>
 #include <errno.h>
+#ifndef _WIN32
+#include <time.h> /* for struct timeval */
+#else
+#include <WinSock2.h>
+#endif
 #include "net.h"
 #include "rules.h"
 #include "json.h"
 
+
 #ifdef _WIN32
 int asprintf(char** ret, char* format, ...){
     va_list args;
@@ -299,11 +304,233 @@ static unsigned int createTest(ruleset *tree, expression *expr, char **test, cha
     return RULES_OK;
 }
 
-static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
+static unsigned int loadPartitionCommand(ruleset *tree, binding *rulesBinding, char *name) {
+    redisContext *reContext = rulesBinding->reContext;
+    redisReply *reply;
+    char *lua = NULL;
+    if (asprintf(&lua, 
+"local partition_key = \"%s!p\"\n"
+"local res = redis.call(\"hget\", partition_key, ARGV[1])\n"
+"if (not res) then\n"
+"   res = redis.call(\"hincrby\", partition_key, \"index\", 1)\n"
+"   res = res %% tonumber(ARGV[2])\n"
+"   redis.call(\"hset\", partition_key, ARGV[1], res)\n"
+"end\n"
+"return tonumber(res)\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->partitionHash, reply->str, 40);
+    rulesBinding->partitionHash[40] = '\0';
+    freeReplyObject(reply);
+    free(lua);
+    return RULES_OK;
+}
+
+static unsigned int loadRemoveActionCommand(ruleset *tree, binding *rulesBinding, char *name) {
+    redisContext *reContext = rulesBinding->reContext;
+    redisReply *reply;
+    char *lua = NULL;
+    if (asprintf(&lua, 
+"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"
+"        for i = 0, count - 1, 1 do\n"
+"            local packed_frame = redis.call(\"rpop\", rule_action_key)\n"
+"        end\n"
+"    end\n"
+"    return (redis.call(\"llen\", key) > 0)\n"
+"end\n"
+"local sid = ARGV[1]\n"
+"local max_score = tonumber(ARGV[2])\n"
+"local action_key = \"%s!a\"\n"
+"if delete_frame(action_key .. \"!\" .. sid, action_key) then\n"
+"    redis.call(\"zadd\", action_key , max_score, sid)\n"
+"else\n"
+"    redis.call(\"zrem\", action_key, 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);
+        free(lua);
+        return ERR_REDIS_ERROR;
+    }
+
+    strncpy(rulesBinding->removeActionHash, reply->str, 40);
+    rulesBinding->removeActionHash[40] = '\0';
+    freeReplyObject(reply);
+    free(lua);
+    return RULES_OK;
+}
+
+static unsigned int loadTimerCommand(ruleset *tree, binding *rulesBinding, char *name) {
     redisContext *reContext = rulesBinding->reContext;
     redisReply *reply;
+    char *lua = NULL;
+    if (asprintf(&lua,
+"local timer_key = \"%s!t\"\n"
+"local timestamp = tonumber(ARGV[1])\n"
+"local res = redis.call(\"zrangebyscore\", timer_key, 0, timestamp, \"limit\", 0, 10)\n"
+"if #res > 0 then\n"
+"  for i = 0, #res, 1 do\n"
+"    redis.call(\"zincrby\", timer_key, 10, res[i])\n"
+"  end\n"
+"  return res\n"
+"end\n"
+"return 0\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->timersHash, reply->str, 40);
+    rulesBinding->timersHash[40] = '\0';
+    freeReplyObject(reply);
+    free(lua);
+    return RULES_OK;
+}
+
+static unsigned int loadUpdateActionCommand(ruleset *tree, binding *rulesBinding, char *name) {
+    redisContext *reContext = rulesBinding->reContext;
+    redisReply *reply;
+    char *lua = NULL;
+    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);
+    return RULES_OK;
+}
+
+static unsigned int setNames(ruleset *tree, binding *rulesBinding, char *name) {
+    int nameLength = strlen(name);
+    char *sessionHashset = malloc((nameLength + 3) * sizeof(char));
+    if (!sessionHashset) {
+        return ERR_OUT_OF_MEMORY;
+    }
+
+    strncpy(sessionHashset, name, nameLength);
+    sessionHashset[nameLength] = '!';
+    sessionHashset[nameLength + 1] = 's';
+    sessionHashset[nameLength + 2] = '\0';
+    rulesBinding->sessionHashset = sessionHashset;
+
+    char *factsHashset = malloc((nameLength + 3) * sizeof(char));
+    if (!factsHashset) {
+        return ERR_OUT_OF_MEMORY;
+    }
+
+    strncpy(factsHashset, name, nameLength);
+    factsHashset[nameLength] = '!';
+    factsHashset[nameLength + 1] = 'f';
+    factsHashset[nameLength + 2] = '\0';
+    rulesBinding->factsHashset = factsHashset;
+
+    char *eventsHashset = malloc((nameLength + 3) * sizeof(char));
+    if (!eventsHashset) {
+        return ERR_OUT_OF_MEMORY;
+    }
+
+    strncpy(eventsHashset, name, nameLength);
+    eventsHashset[nameLength] = '!';
+    eventsHashset[nameLength + 1] = 'e';
+    eventsHashset[nameLength + 2] = '\0';
+    rulesBinding->eventsHashset = eventsHashset;
+
+    char *timersSortedset = malloc((nameLength + 3) * sizeof(char));
+    if (!timersSortedset) {
+        return ERR_OUT_OF_MEMORY;
+    }
+
+    strncpy(timersSortedset, name, nameLength);
+    timersSortedset[nameLength] = '!';
+    timersSortedset[nameLength + 1] = 't';
+    timersSortedset[nameLength + 2] = '\0';
+    rulesBinding->timersSortedset = timersSortedset;
+    return RULES_OK;
+}
+
+static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
     char *name = &tree->stringPool[tree->nameOffset];
     int nameLength = strlen(name);
+    unsigned int result = loadPartitionCommand(tree, rulesBinding, name);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    // client queues have no commands to load, 
+    if (!tree->stringPool) {
+        return RULES_OK;
+    }
+
+    result = loadRemoveActionCommand(tree, rulesBinding, name);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    result = loadTimerCommand(tree, rulesBinding, name);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    result = loadUpdateActionCommand(tree, rulesBinding, name);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    result = setNames(tree, rulesBinding, name);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    redisContext *reContext = rulesBinding->reContext;
+    redisReply *reply;
 #ifdef _WIN32
     char *actionKey = (char *)_alloca(sizeof(char)*(nameLength + 3));
     sprintf_s(actionKey, nameLength + 3, "%s!a", name);
@@ -1444,7 +1671,7 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
 "        for i = 1, #frame, 1 do\n"
 "            if type(frame[i]) == \"table\" then\n"
 "                redis.call(\"hsetnx\", events_hashset, frame[i][\"id\"], cmsgpack.pack(frame[i]))\n"
-"                redis.call(\"zadd\", timers_key, max_score, cjson.encode(frame[i]))\n"
+"                redis.call(\"zadd\", timers_key, max_score, \"p:\" .. cjson.encode(frame[i]))\n"
 "            end\n"
 "        end\n"
 "        full_frame = nil\n"
@@ -1661,170 +1888,6 @@ static unsigned int loadCommands(ruleset *tree, binding *rulesBinding) {
     freeReplyObject(reply);
     free(lua);
 
-    if (asprintf(&lua, 
-"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"
-"        for i = 0, count - 1, 1 do\n"
-"            local packed_frame = redis.call(\"rpop\", rule_action_key)\n"
-"        end\n"
-"    end\n"
-"    return (redis.call(\"llen\", key) > 0)\n"
-"end\n"
-"local sid = ARGV[1]\n"
-"local max_score = tonumber(ARGV[2])\n"
-"local action_key = \"%s!a\"\n"
-"if delete_frame(action_key .. \"!\" .. sid, action_key) then\n"
-"    redis.call(\"zadd\", action_key , max_score, sid)\n"
-"else\n"
-"    redis.call(\"zrem\", action_key, 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);
-        free(lua);
-        return ERR_REDIS_ERROR;
-    }
-
-    strncpy(rulesBinding->removeActionHash, reply->str, 40);
-    rulesBinding->removeActionHash[40] = '\0';
-    freeReplyObject(reply);
-    free(lua);
-
-    if (asprintf(&lua, 
-"local partition_key = \"%s!p\"\n"
-"local res = redis.call(\"hget\", partition_key, ARGV[1])\n"
-"if (not res) then\n"
-"   res = redis.call(\"hincrby\", partition_key, \"index\", 1)\n"
-"   res = res %% tonumber(ARGV[2])\n"
-"   redis.call(\"hset\", partition_key, ARGV[1], res)\n"
-"end\n"
-"return tonumber(res)\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->partitionHash, reply->str, 40);
-    rulesBinding->partitionHash[40] = '\0';
-    freeReplyObject(reply);
-    free(lua);
-
-    if (asprintf(&lua,
-"local timer_key = \"%s!t\"\n"
-"local timestamp = tonumber(ARGV[1])\n"
-"local res = redis.call(\"zrangebyscore\", timer_key, 0, timestamp, \"limit\", 0, 10)\n"
-"if #res > 0 then\n"
-"  for i = 0, #res, 1 do\n"
-"    redis.call(\"zincrby\", timer_key, 10, res[i])\n"
-"  end\n"
-"  return res\n"
-"end\n"
-"return 0\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->timersHash, reply->str, 40);
-    rulesBinding->timersHash[40] = '\0';
-    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;
-    }
-
-    strncpy(sessionHashset, name, nameLength);
-    sessionHashset[nameLength] = '!';
-    sessionHashset[nameLength + 1] = 's';
-    sessionHashset[nameLength + 2] = '\0';
-    rulesBinding->sessionHashset = sessionHashset;
-
-    char *factsHashset = malloc((nameLength + 3) * sizeof(char));
-    if (!factsHashset) {
-        return ERR_OUT_OF_MEMORY;
-    }
-
-    strncpy(factsHashset, name, nameLength);
-    factsHashset[nameLength] = '!';
-    factsHashset[nameLength + 1] = 'f';
-    factsHashset[nameLength + 2] = '\0';
-    rulesBinding->factsHashset = factsHashset;
-
-    char *eventsHashset = malloc((nameLength + 3) * sizeof(char));
-    if (!eventsHashset) {
-        return ERR_OUT_OF_MEMORY;
-    }
-
-    strncpy(eventsHashset, name, nameLength);
-    eventsHashset[nameLength] = '!';
-    eventsHashset[nameLength + 1] = 'e';
-    eventsHashset[nameLength + 2] = '\0';
-    rulesBinding->eventsHashset = eventsHashset;
-
-    char *timersSortedset = malloc((nameLength + 3) * sizeof(char));
-    if (!timersSortedset) {
-        return ERR_OUT_OF_MEMORY;
-    }
-
-    strncpy(timersSortedset, name, nameLength);
-    timersSortedset[nameLength] = '!';
-    timersSortedset[nameLength + 1] = 't';
-    timersSortedset[nameLength + 2] = '\0';
-    rulesBinding->timersSortedset = timersSortedset;
-
     return RULES_OK;
 }
 
@@ -2302,12 +2365,15 @@ static unsigned int tryGetReply(redisContext *reContext,
 
     if (redisGetReply(reContext, (void**)reply) != REDIS_OK) {
         printf("getReply err %d, %d, %s\n", reContext->err, errno, reContext->errstr);
+        #ifndef _WIN32
         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;
+        #else
+        return ERR_REDIS_ERROR;
+        #endif
     }
 
     return RULES_OK;
@@ -2514,7 +2580,7 @@ unsigned int registerTimer(void *rulesBinding, unsigned int duration, char *time
     time_t currentTime = time(NULL);
 
     int result = redisAppendCommand(reContext, 
-                                    "zadd %s %ld %s", 
+                                    "zadd %s %ld p:%s", 
                                     currentBinding->timersSortedset, 
                                     currentTime + duration, 
                                     timer);
@@ -2543,7 +2609,7 @@ unsigned int removeTimer(void *rulesBinding, char *timer) {
     redisContext *reContext = currentBinding->reContext;   
     
     int result = redisAppendCommand(reContext, 
-                                    "zrem %s %s", 
+                                    "zrem %s p:%s", 
                                     currentBinding->timersSortedset,
                                     timer);
     if (result != REDIS_OK) {
@@ -2566,16 +2632,37 @@ unsigned int removeTimer(void *rulesBinding, char *timer) {
     return RULES_OK;
 }
 
-unsigned int registerMessage(void *rulesBinding, char *destination, char *message) {
+unsigned int registerMessage(void *rulesBinding, unsigned int queueAction, 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);
+    int result = REDIS_OK;
+
+    switch (queueAction) {
+        case QUEUE_ASSERT_FACT:
+            result = redisAppendCommand(reContext, 
+                                        "zadd %s!t %ld a:%s", 
+                                        destination, 
+                                        currentTime, 
+                                        message);
+            break;
+        case QUEUE_ASSERT_EVENT:
+            result = redisAppendCommand(reContext, 
+                                        "zadd %s!t %ld p:%s", 
+                                        destination, 
+                                        currentTime, 
+                                        message);
+            break;
+        case QUEUE_RETRACT_FACT:
+            result = redisAppendCommand(reContext, 
+                                        "zadd %s!t %ld r:%s", 
+                                        destination, 
+                                        currentTime, 
+                                        message);
+            break;
+    }
+    
     if (result != REDIS_OK) {
         return ERR_REDIS_ERROR;
     }

data/src/rules/net.h

@@ -137,6 +137,7 @@ unsigned int removeTimer(void *rulesBinding,
                          char *timer);
 
 unsigned int registerMessage(void *rulesBinding, 
+                             unsigned int queueAction,
                              char *destination, 
                              char *message);
 

data/src/rules/rete.c

@@ -1722,5 +1722,62 @@ unsigned int deleteRuleset(void *handle) {
     return RULES_OK;
 }
 
+unsigned int createClient(void **handle, char *name, unsigned int stateCaheSize) {
+    ruleset *tree = malloc(sizeof(ruleset));
+    if (!tree) {
+        return ERR_OUT_OF_MEMORY;
+    }
+    
+    tree->stringPool = NULL;
+    tree->stringPoolLength = 0;
+    tree->nodePool = NULL;
+    tree->nodeOffset = 0;
+    tree->nextPool = NULL;
+    tree->nextOffset = 0;
+    tree->expressionPool = NULL;
+    tree->expressionOffset = 0;
+    tree->idiomPool = NULL;
+    tree->idiomOffset = 0;
+    tree->joinPool = NULL;
+    tree->joinOffset = 0;
+    tree->actionCount = 0;
+    tree->bindingsList = NULL;
+    tree->stateLength = 0;
+    tree->state = calloc(stateCaheSize, sizeof(stateEntry));
+    tree->maxStateLength = stateCaheSize;
+    tree->stateBucketsLength = stateCaheSize / 4;
+    tree->stateBuckets = malloc(tree->stateBucketsLength * sizeof(unsigned int));
+    memset(tree->stateBuckets, 0xFF, tree->stateBucketsLength * sizeof(unsigned int));
+    tree->lruStateOffset = UNDEFINED_HASH_OFFSET;
+    tree->mruStateOffset = UNDEFINED_HASH_OFFSET;
+
+    unsigned int result = storeString(tree, name, &tree->nameOffset, strlen(name));
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    *handle = tree;
+    return RULES_OK;
+}
+
+unsigned int deleteClient(void *handle) {
+    ruleset *tree = (ruleset*)(handle);
+    deleteBindingsList(tree);
+    free(tree->stringPool);
+    free(tree->stateBuckets);
+    for (unsigned int i = 0; i < tree->stateLength; ++i) {
+        stateEntry *entry = &tree->state[i];
+        if (entry->state) {
+            free(entry->state);
+        }
+
+        if (entry->sid) {
+            free(entry->sid);
+        }
+    }
+    
+    free(tree);
+    return RULES_OK;
+}
 
 

data/src/rules/rules.h

@@ -43,6 +43,10 @@
 #define BETA_LIST_LENGTH 16
 #define HASH_MASK 0x1F
 
+#define QUEUE_ASSERT_FACT 1
+#define QUEUE_ASSERT_EVENT 2
+#define QUEUE_RETRACT_FACT 3
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -54,6 +58,12 @@ unsigned int createRuleset(void **handle,
 
 unsigned int deleteRuleset(void *handle);
 
+unsigned int createClient(void **handle, 
+                          char *name,
+                          unsigned int stateCaheSize);
+
+unsigned int deleteClient(void *handle);
+
 unsigned int bindRuleset(void *handle, 
                          char *host, 
                          unsigned int port, 
@@ -161,7 +171,8 @@ unsigned int cancelTimer(void *handle,
                          char *sid, 
                          char *timer);
 
-unsigned int queueMessage(void *handle, 
+unsigned int queueMessage(void *handle,
+                          unsigned int queueAction, 
                           char *sid, 
                           char *destination, 
                           char *message);

data/src/rulesrb/rules.c

@@ -35,6 +35,38 @@ static VALUE rbDeleteRuleset(VALUE self, VALUE handle) {
     return Qnil;
 }
 
+static VALUE rbCreateClient(VALUE self, VALUE name, VALUE stateCacheSize) {
+    Check_Type(name, T_STRING);
+    Check_Type(stateCacheSize, T_FIXNUM);
+
+    void *output = NULL;
+    unsigned int result = createClient(&output, RSTRING_PTR(name), FIX2INT(stateCacheSize));
+    if (result != RULES_OK) {
+        if (result == ERR_OUT_OF_MEMORY) {
+            rb_raise(rb_eNoMemError, "Out of memory");
+        } else { 
+            rb_raise(rb_eException, "Could not create client, error code: %d", result);
+        }
+    }
+
+    return INT2FIX(output);
+}
+
+static VALUE rbDeleteClient(VALUE self, VALUE handle) {
+    Check_Type(handle, T_FIXNUM);
+
+    unsigned int result = deleteClient((void *)FIX2LONG(handle));
+    if (result != RULES_OK) {
+        if (result == ERR_OUT_OF_MEMORY) {
+            rb_raise(rb_eNoMemError, "Out of memory");
+        } else { 
+            rb_raise(rb_eException, "Could not delete client, error code: %d", result);
+        }
+    }
+
+    return Qnil;
+}
+
 static VALUE rbBindRuleset(VALUE self, VALUE handle, VALUE host, VALUE port, VALUE password) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(host, T_STRING);
@@ -124,18 +156,18 @@ static VALUE rbAssertEvent(VALUE self, VALUE handle, VALUE event) {
     return Qnil;
 }
 
-static VALUE rbQueueEvent(VALUE self, VALUE handle, VALUE sid, VALUE destination, VALUE event) {
+static VALUE rbQueueAssertEvent(VALUE self, VALUE handle, VALUE sid, VALUE destination, VALUE event) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(sid, T_STRING);
     Check_Type(destination, T_STRING);
     Check_Type(event, T_STRING);
 
-    unsigned int result = queueMessage((void *)FIX2LONG(handle), RSTRING_PTR(sid), RSTRING_PTR(destination), RSTRING_PTR(event));
+    unsigned int result = queueMessage((void *)FIX2LONG(handle), QUEUE_ASSERT_EVENT, RSTRING_PTR(sid), RSTRING_PTR(destination), RSTRING_PTR(event));
     if (result != RULES_OK) {
         if (result == ERR_OUT_OF_MEMORY) {
             rb_raise(rb_eNoMemError, "Out of memory");
         } else { 
-            rb_raise(rb_eException, "Could not queue event, error code: %d", result);
+            rb_raise(rb_eException, "Could not queue assert event, error code: %d", result);
         }
     }
 
@@ -272,6 +304,24 @@ static VALUE rbAssertFact(VALUE self, VALUE handle, VALUE fact) {
     return Qnil;
 }
 
+static VALUE rbQueueAssertFact(VALUE self, VALUE handle, VALUE sid, VALUE destination, VALUE event) {
+    Check_Type(handle, T_FIXNUM);
+    Check_Type(sid, T_STRING);
+    Check_Type(destination, T_STRING);
+    Check_Type(event, T_STRING);
+
+    unsigned int result = queueMessage((void *)FIX2LONG(handle), QUEUE_ASSERT_FACT, RSTRING_PTR(sid), RSTRING_PTR(destination), RSTRING_PTR(event));
+    if (result != RULES_OK) {
+        if (result == ERR_OUT_OF_MEMORY) {
+            rb_raise(rb_eNoMemError, "Out of memory");
+        } else { 
+            rb_raise(rb_eException, "Could not queue assert fact, error code: %d", result);
+        }
+    }
+
+    return Qnil;
+}
+
 static VALUE rbStartAssertFacts(VALUE self, VALUE handle, VALUE facts) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(facts, T_STRING);
@@ -382,6 +432,24 @@ static VALUE rbRetractFact(VALUE self, VALUE handle, VALUE fact) {
     return Qnil;
 }
 
+static VALUE rbQueueRetractFact(VALUE self, VALUE handle, VALUE sid, VALUE destination, VALUE event) {
+    Check_Type(handle, T_FIXNUM);
+    Check_Type(sid, T_STRING);
+    Check_Type(destination, T_STRING);
+    Check_Type(event, T_STRING);
+
+    unsigned int result = queueMessage((void *)FIX2LONG(handle), QUEUE_RETRACT_FACT, RSTRING_PTR(sid), RSTRING_PTR(destination), RSTRING_PTR(event));
+    if (result != RULES_OK) {
+        if (result == ERR_OUT_OF_MEMORY) {
+            rb_raise(rb_eNoMemError, "Out of memory");
+        } else { 
+            rb_raise(rb_eException, "Could not queue retract fact, error code: %d", result);
+        }
+    }
+
+    return Qnil;
+}
+
 static VALUE rbStartRetractFacts(VALUE self, VALUE handle, VALUE facts) {
     Check_Type(handle, T_FIXNUM);
     Check_Type(facts, T_STRING);
@@ -667,20 +735,24 @@ void Init_rules() {
     rulesModule = rb_define_module("Rules");
     rb_define_singleton_method(rulesModule, "create_ruleset", rbCreateRuleset, 3);
     rb_define_singleton_method(rulesModule, "delete_ruleset", rbDeleteRuleset, 1);
+    rb_define_singleton_method(rulesModule, "create_client", rbCreateClient, 2);
+    rb_define_singleton_method(rulesModule, "delete_client", rbDeleteClient, 1);
     rb_define_singleton_method(rulesModule, "bind_ruleset", rbBindRuleset, 4);
     rb_define_singleton_method(rulesModule, "complete", rbComplete, 2);
     rb_define_singleton_method(rulesModule, "assert_event", rbAssertEvent, 2);
-    rb_define_singleton_method(rulesModule, "queue_event", rbQueueEvent, 4);
+    rb_define_singleton_method(rulesModule, "queue_assert_event", rbQueueAssertEvent, 4);
     rb_define_singleton_method(rulesModule, "start_assert_event", rbStartAssertEvent, 2);
     rb_define_singleton_method(rulesModule, "assert_events", rbAssertEvents, 2);
     rb_define_singleton_method(rulesModule, "start_assert_events", rbStartAssertEvents, 2);
     rb_define_singleton_method(rulesModule, "retract_event", rbRetractEvent, 2);
     rb_define_singleton_method(rulesModule, "start_assert_fact", rbStartAssertFact, 2);
     rb_define_singleton_method(rulesModule, "assert_fact", rbAssertFact, 2);
+    rb_define_singleton_method(rulesModule, "queue_assert_fact", rbQueueAssertFact, 4);
     rb_define_singleton_method(rulesModule, "start_assert_facts", rbStartAssertFacts, 2);
     rb_define_singleton_method(rulesModule, "assert_facts", rbAssertFacts, 2);
     rb_define_singleton_method(rulesModule, "start_retract_fact", rbStartRetractFact, 2);
     rb_define_singleton_method(rulesModule, "retract_fact", rbRetractFact, 2);
+    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);

metadata

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