durable_rules 2.0.20 → 2.0.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e31ed367e85b98094b59ee77e36313d16f55050f
-  data.tar.gz: 1d569b73e027e8078d4f46d9d464e57ae0a3213e
+  metadata.gz: cc03b88548e96951b82c22fe1ddf28d275130f79
+  data.tar.gz: da5f07e4f707e4aa68fa73077f023bb4dd046c97
 SHA512:
-  metadata.gz: 0e9916597fe2a07f54946da6ceeb6dec73d0c1d6ab995b6bf4d8c960c4168ebe320e0419d03e55cda12d7b764bdc8ddf2bce9f62de38a32a7c4a7eef0e223281
-  data.tar.gz: e53b6782a8e0d6692890e62ddc500d932ebdc416635bfd07d2538b27ef15944eb8b34a9362d0c3500efa3169db1f3f688bc2a03ba4cd8e755523053b49809b63
+  metadata.gz: 4c204fd504883152da43e0f6586fea6ed1898b1200b0844b4e9d0e80cc2dcd261dd1e9f25d9627c79c8d3c709806d97743bf4b0fcaa561a1231167ed771793f0
+  data.tar.gz: d698a703e5e87fe9d3e478ad8e416ebe2c2ac8f1fa038f2856c3ca0dc532db8555a63bc5b2cf6d25e98dadbdb6fbbd64bbba34fe09c7aef83c449b9256845ee1

data/librb/durable.rb

@@ -43,14 +43,22 @@ module Durable
     self.get_host().update_state ruleset_name, state, complete
   end
 
-  def self.get_state(ruleset_name, sid)
+  def self.get_state(ruleset_name, sid = nil)
     self.get_host().get_state ruleset_name, sid
   end
 
-  def self.delete_state(ruleset_name, sid)
+  def self.delete_state(ruleset_name, sid = nil)
     self.get_host().delete_state ruleset_name, sid
   end
 
+  def self.get_facts(ruleset_name, sid = nil)
+    self.get_host().get_facts ruleset_name, sid
+  end
+
+  def self.get_pending_events(ruleset_name, sid = nil)
+    self.get_host().get_pending_events ruleset_name, sid
+  end
+
   def self.ruleset(name, &block) 
     ruleset = Ruleset.new name, block
     @@rulesets[name] = ruleset.rules

data/librb/engine.rb

@@ -144,6 +144,14 @@ module Engine
       @_deleted = true
     end
 
+    def get_facts()
+      @_ruleset.get_facts @s.sid
+    end
+
+    def get_pending_events()
+      @_ruleset.get_pending_events @s.sid
+    end
+
     def has_completed()
       if Time.now - @_start_time > 10000
         @_completed = true
@@ -395,17 +403,45 @@ module Engine
     end
 
     def get_state(sid)
+      if sid == nil
+        sid = "0"
+      end
+
       JSON.parse Rules.get_state(@handle, sid.to_s)
     end
 
     def delete_state(sid)
+      if sid == nil
+        sid = "0"
+      end
+
       Rules.delete_state(@handle, sid.to_s)
     end
 
     def renew_action_lease(sid)
+      if sid == nil
+        sid = "0"
+      end
+
       Rules.renew_action_lease @handle, sid.to_s
     end
 
+    def get_facts(sid)
+      if sid == nil
+        sid = "0"
+      end
+
+      JSON.parse Rules.get_facts(@handle, sid.to_s)
+    end
+
+    def get_pending_events(sid)
+      if sid == nil
+        sid = "0"
+      end
+
+      JSON.parse Rules.get_events(@handle, sid)
+    end
+
     def Ruleset.create_rulesets(host, ruleset_definitions)
       branches = {}
       for name, definition in ruleset_definitions do
@@ -983,18 +1019,26 @@ module Engine
       handle_function rules, @update_state_func, state, complete
     end
 
-    def get_state(ruleset_name, sid)
+    def get_state(ruleset_name, sid = nil)
       get_ruleset(ruleset_name).get_state sid
     end
 
-    def delete_state(ruleset_name, sid)
+    def delete_state(ruleset_name, sid = nil)
       get_ruleset(ruleset_name).delete_state sid
     end
 
-    def renew_action_lease(ruleset_name, sid)
+    def renew_action_lease(ruleset_name, sid = nil)
       get_ruleset(ruleset_name).renew_action_lease sid
     end
 
+    def get_facts(ruleset_name, sid = nil)
+      get_ruleset(ruleset_name).get_facts sid
+    end
+
+    def get_pending_events(ruleset_name, sid = nil)
+      get_ruleset(ruleset_name).get_pending_events sid
+    end
+
     def register_rulesets(ruleset_definitions)
       rulesets = Ruleset.create_rulesets(self, ruleset_definitions)
       for ruleset_name, ruleset in rulesets do

data/src/rules/rules.h

@@ -221,6 +221,14 @@ unsigned int deleteState(unsigned int handle,
 unsigned int renewActionLease(unsigned int handle, 
                               char *sid);
 
+unsigned int getEvents(unsigned int handle, 
+                       char *sid, 
+                       char **messages);
+
+unsigned int getFacts(unsigned int handle, 
+                      char *sid, 
+                      char **messages);
+
 #ifdef _WIN32
 int asprintf(char** ret, char* format, ...);
 #endif

data/src/rules/state.c

@@ -957,9 +957,13 @@ unsigned int deleteStateNode(void *tree,
     }   
     free(node->actionState);
 
-    for (unsigned int i = 0; i < MAX_MESSAGE_INDEX_LENGTH * 2; ++i) {
-        if (node->messageIndex[i] != UNDEFINED_HASH_OFFSET) {
-            deleteMessage(tree, node, NULL, node->messageIndex[i]);
+    for (unsigned int i = 0; i < MAX_MESSAGE_INDEX_LENGTH; ++i) {
+        unsigned int currentMessageOffset = node->messageIndex[i * 2];
+        while (currentMessageOffset != UNDEFINED_HASH_OFFSET) {
+            messageNode *currentMessageNode = MESSAGE_NODE(node, currentMessageOffset);
+            unsigned int nextMessageOffset = currentMessageNode->nextOffset; 
+            deleteMessage(tree, node, NULL, currentMessageOffset);
+            currentMessageOffset = nextMessageOffset;
         }
     }
     free(node->messagePool.content);
@@ -1131,20 +1135,6 @@ unsigned int serializeResult(void *tree,
     return RULES_OK;
 }
 
-unsigned int serializeState(stateNode *state, 
-                            char **stateFact) {
-
-    messageNode *stateFactNode = MESSAGE_NODE(state, state->factOffset);
-    unsigned int stateFactLength = strlen(stateFactNode->jo.content) + 1;
-    *stateFact = malloc(stateFactLength * sizeof(char));
-    if (!*stateFact) {
-        return ERR_OUT_OF_MEMORY;
-    }
-    memcpy(*stateFact, stateFactNode->jo.content, stateFactLength);
-
-    return RULES_OK;
-}
-
 unsigned int getNextResultInState(void *tree, 
                                   time_t currentTime,
                                   stateNode *state,
@@ -1547,33 +1537,150 @@ unsigned int constructObject(char *root,
     return (result == PARSE_END ? RULES_OK: result);
 }
 
-unsigned int getState(unsigned int handle, char *sid, char **state) {
+static unsigned int getMessagesLength(stateNode *state, 
+                                      char messageType,
+                                      unsigned int *messageCount) {
+    unsigned int resultLength = 2;
+    *messageCount = 0;
+    for (unsigned int i = 0; i < MAX_MESSAGE_INDEX_LENGTH; ++i) {
+        unsigned int currentMessageOffset = state->messageIndex[i * 2];
+        while (currentMessageOffset != UNDEFINED_HASH_OFFSET) {
+            messageNode *currentMessageNode = MESSAGE_NODE(state, currentMessageOffset);
+            if (currentMessageNode->messageType == messageType) {
+                ++*messageCount;
+                resultLength += strlen(currentMessageNode->jo.content) + 1;
+            }
+            currentMessageOffset = currentMessageNode->nextOffset;
+        }
+    }
+
+    if (!*messageCount) {
+        ++resultLength;
+    }
+    
+    return resultLength;
+}
+ 
+static unsigned int serializeMessages(stateNode *state, 
+                                      char messageType,
+                                      unsigned int messageCount, 
+                                      char *messages) {
+
+    messages[0] = '['; 
+    ++messages;
+    unsigned int currentMessageCount = 0;
+    for (unsigned int i = 0; i < MAX_MESSAGE_INDEX_LENGTH && currentMessageCount < messageCount; ++i) {
+        unsigned int currentMessageOffset = state->messageIndex[i * 2];
+        while (currentMessageOffset != UNDEFINED_HASH_OFFSET && currentMessageCount < messageCount) {
+            messageNode *currentMessageNode = MESSAGE_NODE(state, currentMessageOffset);
+            if (currentMessageNode->messageType == messageType) {
+                ++currentMessageCount;
+                unsigned int tupleLength = strlen(currentMessageNode->jo.content) + 1;
+                if (currentMessageCount < messageCount) {
+                    ++tupleLength;
+#ifdef _WIN32
+                    sprintf_s(messages, tupleLength, "%s,", currentMessageNode->jo.content);
+#else
+                    snprintf(messages, tupleLength, "%s,", currentMessageNode->jo.content);
+#endif
+                } else {
+#ifdef _WIN32
+                    sprintf_s(messages, tupleLength, "%s", currentMessageNode->jo.content);
+#else
+                    snprintf(messages, tupleLength, "%s", currentMessageNode->jo.content);
+#endif   
+                }
+
+                messages += (tupleLength - 1);
+            }
+            currentMessageOffset = currentMessageNode->nextOffset;
+        }
+    }
+
+    messages[0] = ']';
+    messages[1] = 0;
+    return RULES_OK;
+}
+
+
+static unsigned int getMessagesForType(unsigned int handle, 
+                                       char *sid, 
+                                       char messageType, 
+                                       char **messages) {
     ruleset *tree;
     RESOLVE_HANDLE(handle, &tree);
 
     if (!sid) {
         sid = "0";
     }
-    unsigned int sidHash = fnv1Hash32(sid, strlen(sid));
-    unsigned int nodeOffset;
 
-    GET_FIRST(stateNode, 
-             tree->stateIndex, 
-             MAX_STATE_INDEX_LENGTH, 
-             ((ruleset*)tree)->statePool, 
-             sidHash, 
-             nodeOffset);
+    stateNode *state = NULL;
+    CHECK_RESULT(getStateNode(tree, sid, &state));
 
-    if (nodeOffset == UNDEFINED_HASH_OFFSET) {
-      return ERR_SID_NOT_FOUND;
+    unsigned int messageCount = 0;
+    unsigned int messagesLength = getMessagesLength(state, 
+                                                    messageType, 
+                                                    &messageCount);
+
+    *messages = malloc(messagesLength * sizeof(char));
+    if (!*messages) {
+        return ERR_OUT_OF_MEMORY;
     }
 
-    stateNode *node = STATE_NODE(tree, nodeOffset); 
+    return serializeMessages(state, 
+                             messageType, 
+                             messageCount, 
+                             *messages);
+    
+}
 
-    return serializeState(node, state);
+unsigned int getEvents(unsigned int handle, 
+                       char *sid, 
+                       char **messages) {
+
+    return getMessagesForType(handle,
+                              sid,
+                              MESSAGE_TYPE_EVENT,
+                              messages);
+
+}
+
+unsigned int getFacts(unsigned int handle, 
+                      char *sid, 
+                      char **messages) {
+
+    return getMessagesForType(handle,
+                              sid,
+                              MESSAGE_TYPE_FACT,
+                              messages);
+
+}
+
+unsigned int serializeState(stateNode *state, char **stateFact) {
+    messageNode *stateFactNode = MESSAGE_NODE(state, state->factOffset);
+    unsigned int stateFactLength = strlen(stateFactNode->jo.content) + 1;
+    *stateFact = malloc(stateFactLength * sizeof(char));
+    if (!*stateFact) {
+        return ERR_OUT_OF_MEMORY;
+    }
+    memcpy(*stateFact, stateFactNode->jo.content, stateFactLength);
+
+    return RULES_OK;
 }
 
+unsigned int getState(unsigned int handle, char *sid, char **state) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    if (!sid) {
+        sid = "0";
+    }
+
+    stateNode *node = NULL;
+    CHECK_RESULT(getStateNode(tree, sid, &node));
 
+    return serializeState(node, state);
+}
 
 unsigned int deleteState(unsigned int handle, char *sid) {
     ruleset *tree;

data/src/rulesrb/rules.c

@@ -371,6 +371,46 @@ static VALUE rbRenewActionLease(VALUE self, VALUE handle, VALUE sid) {
     return Qnil;
 }
 
+static VALUE rbGetFacts(VALUE self, VALUE handle, VALUE sid) {
+    Check_Type(handle, T_FIXNUM);
+    Check_Type(sid, T_STRING);
+
+    char *facts;
+    unsigned int result = getFacts(FIX2INT(handle), RSTRING_PTR(sid), &facts);
+    if (result != RULES_OK) {
+        if (result == ERR_OUT_OF_MEMORY) {
+            rb_raise(rb_eNoMemError, "Out of memory");
+        } else { 
+            rb_raise(rb_eException, "Could not get facts, error code: %d", result);
+        }
+    }
+
+    VALUE output = rb_str_new2(facts);
+    free(facts);
+    return output;
+}
+
+
+static VALUE rbGetEvents(VALUE self, VALUE handle, VALUE sid) {
+    Check_Type(handle, T_FIXNUM);
+    Check_Type(sid, T_STRING);
+
+    char *events;
+    unsigned int result = getEvents(FIX2INT(handle), RSTRING_PTR(sid), &events);
+    if (result != RULES_OK) {
+        if (result == ERR_OUT_OF_MEMORY) {
+            rb_raise(rb_eNoMemError, "Out of memory");
+        } else { 
+            rb_raise(rb_eException, "Could not get events, error code: %d", result);
+        }
+    }
+
+    VALUE output = rb_str_new2(events);
+    free(events);
+    return output;
+}
+
+
 void Init_rules() {
     rulesModule = rb_define_module("Rules");
     rb_define_singleton_method(rulesModule, "create_ruleset", rbCreateRuleset, 2);
@@ -392,6 +432,8 @@ void Init_rules() {
     rb_define_singleton_method(rulesModule, "get_state", rbGetState, 2);
     rb_define_singleton_method(rulesModule, "delete_state", rbDeleteState, 2);
     rb_define_singleton_method(rulesModule, "renew_action_lease", rbRenewActionLease, 2);
+    rb_define_singleton_method(rulesModule, "get_facts", rbGetFacts, 2);
+    rb_define_singleton_method(rulesModule, "get_events", rbGetEvents, 2);
 }
 
 

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: durable_rules
 version: !ruby/object:Gem::Version
-  version: 2.0.20
+  version: 2.0.21
 platform: ruby
 authors:
 - Jesus Ruiz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-07 00:00:00.000000000 Z
+date: 2020-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 10.4.2
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 10.4.2
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement