durable_rules 2.0.6 → 2.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4dd49e4357fbd2d4df00d1055d3f28413f81631
-  data.tar.gz: 8f27a057991ac417017ad5127a2161a0be2accd8
+  metadata.gz: 7c08ea6baf1f7ff23b7b360cbc0a4f5d27361524
+  data.tar.gz: c6e839c804df85c3aa26d752d42ed965c78382f8
 SHA512:
-  metadata.gz: a8c5ad57d5aa1cbdc2b798dfc2c91bab920d127b4ac05190c5a61a2eada58dc2261ee6bf062078ad1c7a4aa42e82e338b2580646ea5f3accefe8459f54063777
-  data.tar.gz: baa4b3ac0b646cf45cd427df314d015dc6a76d3d5d34b6126e2bc24cce39d971b43f540171422e7a874faa896d69573d8a6bba4f7baf5b1cf8e2861ead5d4473
+  metadata.gz: 042ada520d5d8434ccfaeeff78603af18efe209fc80b8033f595e2e521064cb2ff54d1e45edace0bb64cab912f8a6b822c172794ff7f9c039fa088e1b13522e3
+  data.tar.gz: d3f6b93ff29efcdcd1b5c90825965c73aa780a807f47a37c489e6134f660048a657042d63692aa33ea4ea6e1adf45fe6f44632e57dd6289929139c9c47675d7f

data/src/rules/events.c

@@ -776,11 +776,16 @@ static unsigned int handleBetaFrame(ruleset *tree,
                                     node *oldNode,
                                     node *currentNode,
                                     leftFrameNode *oldFrame,
-                                    leftFrameNode *currentFrame) {
+                                    leftFrameNode *currentFrame,
+                                    unsigned char sideEffect) {
     frameLocation currentFrameLocation;
     unsigned int frameType = LEFT_FRAME; 
     
     if (currentNode->type == NODE_ACTION) {
+        if (!sideEffect) {
+            return RULES_OK;
+        }
+
         CHECK_RESULT(createActionFrame(state,
                                        currentNode,
                                        currentFrame,
@@ -898,7 +903,8 @@ static unsigned int handleBetaFrame(ruleset *tree,
                                currentNode,
                                nextNode,
                                NULL,
-                               currentFrame);
+                               currentFrame,
+                               sideEffect);
 
     } else if (currentNode->type == NODE_BETA) {
         // Find all messages for frame 
@@ -926,7 +932,8 @@ static unsigned int handleBetaFrame(ruleset *tree,
                                              currentNode,
                                              nextNode,
                                              NULL,
-                                             currentFrame));
+                                             currentFrame,
+                                             sideEffect));
             }
             
             unsigned int rightFrameOffset = rightFrame->prevOffset;
@@ -959,7 +966,8 @@ static unsigned int handleBetaFrame(ruleset *tree,
                                          currentNode,
                                          nextNode,
                                          connectorFrame,
-                                         currentFrame));
+                                         currentFrame,
+                                         sideEffect));
 
             connectorFrameOffset = connectorFrame->prevOffset;
             if (connectorFrameOffset == UNDEFINED_HASH_OFFSET) {
@@ -983,7 +991,8 @@ static unsigned int handleBetaFrame(ruleset *tree,
                                      currentNode,
                                      nextNode,
                                      NULL,
-                                     currentFrame));
+                                     currentFrame,
+                                     sideEffect));
     } 
 
     return RULES_OK;
@@ -1073,7 +1082,8 @@ static unsigned int handleDeleteMessage(ruleset *tree,
                                                              currentNode,
                                                              nextNode,
                                                              NULL,
-                                                             NULL));
+                                                             NULL,
+                                                             1));
                             }
                         } else {
                             unsigned int messageHash;
@@ -1109,7 +1119,8 @@ static unsigned int handleDeleteMessage(ruleset *tree,
                                                                  currentNode,
                                                                  nextNode,
                                                                  NULL,
-                                                                 currentFrame));
+                                                                 currentFrame,
+                                                                 1));
                                 }
 
                                 unsigned int currentFrameOffset = currentFrame->prevOffset;
@@ -1285,7 +1296,8 @@ static unsigned int handleMatchFrames(ruleset *tree,
                                       node *currentNode,
                                       jsonObject *messageObject,
                                       unsigned int currentMessageOffset,
-                                      unsigned int messageHash) { 
+                                      unsigned int messageHash,
+                                      unsigned char sideEffect) { 
     // Find frames for message
     leftFrameNode *currentFrame = NULL;
     node *nextNode = &tree->nodePool[currentNode->value.b.nextOffset];
@@ -1311,7 +1323,8 @@ static unsigned int handleMatchFrames(ruleset *tree,
                                          currentNode,
                                          nextNode,
                                          NULL,
-                                         currentFrame));
+                                         currentFrame,
+                                         sideEffect));
         }
 
         unsigned int currentFrameOffset = currentFrame->prevOffset;        
@@ -1336,7 +1349,8 @@ static unsigned int handleMatchFrames(ruleset *tree,
                                currentNode, 
                                nextNode,
                                NULL,
-                               NULL);   
+                               NULL,
+                               sideEffect);   
     }
 
     return RULES_OK;
@@ -1346,7 +1360,8 @@ static unsigned int handleBetaMessage(ruleset *tree,
                                       stateNode *state,
                                       node *betaNode,
                                       jsonObject *messageObject,
-                                      unsigned int currentMessageOffset) { 
+                                      unsigned int currentMessageOffset,
+                                      unsigned char sideEffect) { 
     if (betaNode->value.b.isFirst && !betaNode->value.b.not) {
         node *nextNode = &tree->nodePool[betaNode->value.b.nextOffset];
         return handleBetaFrame(tree,
@@ -1355,7 +1370,8 @@ static unsigned int handleBetaMessage(ruleset *tree,
                                betaNode, 
                                nextNode,
                                NULL,
-                               NULL);
+                               NULL,
+                               sideEffect);
     }
 
     frameLocation rightFrameLocation;
@@ -1397,7 +1413,8 @@ static unsigned int handleBetaMessage(ruleset *tree,
                              betaNode,
                              messageObject,
                              currentMessageOffset,
-                             messageHash);
+                             messageHash,
+                             sideEffect);
 }
 
 static unsigned int isArrayMatch(ruleset *tree,
@@ -1589,7 +1606,8 @@ static unsigned int handleAlpha(ruleset *tree,
                                 jsonObject *jo,
                                 unsigned char messageType,
                                 alpha *alphaNode, 
-                                unsigned int *messageOffset) { 
+                                unsigned int *messageOffset,
+                                unsigned char sideEffect) { 
     unsigned short top = 1;
     unsigned int entry;
     unsigned char messageStored = 0;
@@ -1671,6 +1689,7 @@ static unsigned int handleAlpha(ruleset *tree,
                                           mid,
                                           jo,
                                           messageType,
+                                          sideEffect,
                                           messageOffset));
 
                 messageStored = 1;
@@ -1683,7 +1702,8 @@ static unsigned int handleAlpha(ruleset *tree,
                                                state, 
                                                &tree->nodePool[betaList[entry]],
                                                jo,
-                                               *messageOffset));
+                                               *messageOffset,
+                                               sideEffect));
             }
         }
     }
@@ -1695,7 +1715,8 @@ static unsigned int handleMessageCore(ruleset *tree,
                                       jsonObject *jo, 
                                       unsigned char actionType,
                                       unsigned int *messageOffset,
-                                      unsigned int *stateOffset) {
+                                      unsigned int *stateOffset,
+                                      unsigned char sideEffect) {
     stateNode *sidState;
     jsonProperty *sidProperty = &jo->properties[jo->sidIndex];
     jsonProperty *midProperty = &jo->properties[jo->idIndex];
@@ -1763,7 +1784,8 @@ static unsigned int handleMessageCore(ruleset *tree,
                              jo,
                              MESSAGE_TYPE_FACT,
                              &tree->nodePool[NODE_M_OFFSET].value.a,
-                             messageOffset);
+                             messageOffset,
+                             sideEffect);
         if (result != RULES_OK && result != ERR_EVENT_NOT_HANDLED) {
             return result;
         } else if (result == ERR_EVENT_NOT_HANDLED) {
@@ -1771,7 +1793,8 @@ static unsigned int handleMessageCore(ruleset *tree,
                                   sidState,
                                   mid,
                                   jo,
-                                  MESSAGE_TYPE_FACT,
+                                  MESSAGE_TYPE_STATE,
+                                  sideEffect,
                                   messageOffset));
         }
 
@@ -1794,10 +1817,11 @@ static unsigned int handleMessageCore(ruleset *tree,
                                           jo,
                                           (actionType == ACTION_ASSERT_FACT ? MESSAGE_TYPE_FACT : MESSAGE_TYPE_EVENT),
                                           &tree->nodePool[NODE_M_OFFSET].value.a,
-                                          messageOffset);
+                                          messageOffset,
+                                          sideEffect);
 
         if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
-            if (sidState->factOffset == UNDEFINED_HASH_OFFSET) {      
+            if (sideEffect && (sidState->factOffset == UNDEFINED_HASH_OFFSET)) {      
 #ifdef _WIN32
                 char *stateMessage = (char *)_alloca(sizeof(char)*(50 + sidProperty->valueLength * 2));
                 sprintf_s(stateMessage, sizeof(char)*(50 + sidProperty->valueLength * 2), "{ \"sid\":\"%s\", \"id\":\"sid-%s\", \"$s\":1}", sid, sid);
@@ -1846,7 +1870,8 @@ static unsigned int handleMessage(ruleset *tree,
                              &jo,
                              actionType,
                              messageOffset,
-                             stateOffset);
+                             stateOffset,
+                             1);
 }
 
 static unsigned int handleMessages(ruleset *tree, 
@@ -1886,7 +1911,8 @@ static unsigned int handleMessages(ruleset *tree,
                                    &jo, 
                                    actionType, 
                                    &messageOffset,
-                                   stateOffset);
+                                   stateOffset,
+                                   1);
         
         *last = lastTemp;
         if (result != RULES_OK && result != ERR_EVENT_NOT_HANDLED && result != ERR_EVENT_OBSERVED) {
@@ -1941,7 +1967,7 @@ unsigned int assertFacts(unsigned int handle,
     ruleset *tree;
     RESOLVE_HANDLE(handle, &tree);
 
-    return handleMessages(tree, ACTION_ASSERT_EVENT, messages, stateOffset);
+    return handleMessages(tree, ACTION_ASSERT_FACT, messages, stateOffset);
 }
 
 unsigned int retractFact(unsigned int handle, 
@@ -1979,7 +2005,8 @@ unsigned int updateState(unsigned int handle,
 
 static unsigned int replayMessages(ruleset *tree, 
                                    char *messages, 
-                                   unsigned int *stateOffset) {
+                                   unsigned int *stateOffset,
+                                   unsigned char sideEffect) {
     unsigned int result;
     unsigned int messageOffset;
     jsonObject jo;
@@ -1993,7 +2020,6 @@ static unsigned int replayMessages(ruleset *tree,
                          &first, 
                          &last, 
                          &type) == PARSE_OK) {
-
         if (type != JSON_INT) {
             return ERR_UNEXPECTED_TYPE;
         }
@@ -2028,13 +2054,15 @@ static unsigned int replayMessages(ruleset *tree,
             --last;
         }
 
+
         lastTemp = *last;
         *last = '\0';
         result = handleMessageCore(tree,
                                    &jo, 
                                    actionType, 
                                    &messageOffset,
-                                   stateOffset);
+                                   stateOffset,
+                                   sideEffect);
         
         *last = lastTemp;
         if (result != RULES_OK && result != ERR_EVENT_NOT_HANDLED && result != ERR_EVENT_OBSERVED) {
@@ -2048,78 +2076,81 @@ static unsigned int replayMessages(ruleset *tree,
 }
 
 
-static unsigned int flushQueuedActions(ruleset *tree) {
+static unsigned int startQueuedActions(ruleset *tree) {
     if (tree->getIdleStateCallback) {
-        char *sid;
         CHECK_RESULT(tree->getIdleStateCallback(tree->getIdleStateCallbackContext,
-                                                &tree->stringPool[tree->nameOffset],
-                                                &sid));
-        if (sid) {
-            stateNode *state;
-            unsigned int result = getStateNode(tree, 
-                                               sid,
-                                               &state);
-            if (result != RULES_OK && result != ERR_SID_NOT_FOUND) {
-                return result;
-            } else if (result == RULES_OK) {
-                CHECK_RESULT(deleteStateNode(tree,
-                                             state));
-            }
-                
-            CHECK_RESULT(createStateNode(tree, 
-                                         sid,
-                                         &state)); 
-
-            free(sid);
-            if (tree->getStoredMessagesCallback) {
-                char *messages;
-                unsigned int stateOffset;
-                CHECK_RESULT(tree->getStoredMessagesCallback(tree->getStoredMessagesCallbackContext,
-                                                             &tree->stringPool[tree->nameOffset],
-                                                             state->sid,
-                                                             &messages));   
-                if (messages) {
-                    result = replayMessages(tree,
-                                            messages,
-                                            &stateOffset);
-                    
-                    free(messages);
-                    if (result != RULES_OK) {
-                        return result;
-                    }
-                    
-                }
-            }
-        }
+                                                &tree->stringPool[tree->nameOffset]));
     }
 
-
     if (tree->getQueuedMessagesCallback) {
         for (unsigned int index = 0; index < tree->statePool.count; ++index) {
             unsigned int nodeOffset = tree->reverseStateIndex[index];
             stateNode *currentState = STATE_NODE(tree, nodeOffset);
 
-            char *messages;
-            unsigned int stateOffset;
             CHECK_RESULT(tree->getQueuedMessagesCallback(tree->getQueuedMessagesCallbackContext,
                                                          &tree->stringPool[tree->nameOffset],
-                                                         currentState->sid,
-                                                         &messages));
-            if (messages) {
-                unsigned int result = replayMessages(tree,
-                                                     messages,
-                                                     &stateOffset);
-                free(messages);
-                if (result != RULES_OK) {
-                    return result;
-                }
-            }
+                                                         currentState->sid));
         }
     }
 
     return RULES_OK;
 }
 
+unsigned int completeGetIdleState(unsigned int handle, 
+                                  char *sid, 
+                                  char *storedMessages) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+    stateNode *state;
+    unsigned int result = getStateNode(tree, 
+                                       sid,
+                                       &state);
+    if (result != RULES_OK && result != ERR_SID_NOT_FOUND) {
+        return result;
+    } else if (result == RULES_OK) {
+        CHECK_RESULT(deleteStateNode(tree,
+                                     state));
+    }
+        
+    CHECK_RESULT(createStateNode(tree, 
+                                 sid,
+                                 &state)); 
+
+
+    if (storedMessages) {
+        unsigned int stateOffset;
+        CHECK_RESULT(replayMessages(tree,
+                                    storedMessages,
+                                    &stateOffset,
+                                    0));
+    }
+
+    if (tree->getQueuedMessagesCallback) {
+        CHECK_RESULT(tree->getQueuedMessagesCallback(tree->getQueuedMessagesCallbackContext,
+                                                     &tree->stringPool[tree->nameOffset],
+                                                     sid));
+    }
+
+    return RULES_OK;
+}
+
+unsigned int completeGetQueuedMessages(unsigned int handle,
+                                       char *sid,
+                                       char *queuedMessages) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+    stateNode *state;
+    CHECK_RESULT(getStateNode(tree, 
+                              sid,
+                              &state));
+
+    unsigned int stateOffset;
+    return replayMessages(tree,
+                          queuedMessages,
+                          &stateOffset,
+                          1);
+}
+
 unsigned int startAction(unsigned int handle, 
                          char **stateFact, 
                          char **messages, 
@@ -2133,8 +2164,8 @@ unsigned int startAction(unsigned int handle,
     unsigned int resultFrameOffset;
     time_t currentTime = time(NULL);
 
-    CHECK_RESULT(flushQueuedActions(tree));  
-
+    CHECK_RESULT(startQueuedActions(tree));  
+    
     CHECK_RESULT(getNextResult(tree,
                                currentTime,
                                &resultState, 
@@ -2152,7 +2183,7 @@ unsigned int startAction(unsigned int handle,
     CHECK_RESULT(serializeState(resultState, 
                                 &resultState->context.stateFact));
 
-   
+
     resultState->context.actionStateIndex = actionStateIndex;
     resultState->context.resultCount = resultCount;
     resultState->context.resultFrameOffset = resultFrameOffset;

data/src/rules/json.c

@@ -114,7 +114,7 @@ unsigned int readNextString(char *start, char **first, char **last, unsigned int
 
 unsigned int readNextArrayValue(char *start, char **first, char **last, unsigned char *type) {
     unsigned char state = ST_OBJECT_PROP_PARSE;
-    if (start[0] == '[') {
+    if (start[0] == '[' || start[0] == ',') {
         state = ST_OBJECT_PROP_VAL;
     } 
     ++start;

data/src/rules/rete.c

@@ -1860,8 +1860,6 @@ unsigned int createRuleset(unsigned int *handle, char *name, char *rules) {
     tree->queueMessageCallbackContext = NULL;
     tree->getQueuedMessagesCallback = NULL;
     tree->getQueuedMessagesCallbackContext = NULL;
-    tree->getStoredMessagesCallback = NULL;
-    tree->getStoredMessagesCallbackContext = NULL;
     tree->getIdleStateCallback = NULL;
     tree->getIdleStateCallbackContext = NULL;
 
@@ -1939,7 +1937,7 @@ unsigned int setQueueMessageCallback(unsigned int handle,
 
 unsigned int setGetQueuedMessagesCallback(unsigned int handle, 
                                           void *context, 
-                                          unsigned int (*callback)(void *, char *, char *, char **)) {
+                                          unsigned int (*callback)(void *, char *, char *)) {
     ruleset *tree;
     RESOLVE_HANDLE(handle, &tree);
 
@@ -1948,20 +1946,9 @@ unsigned int setGetQueuedMessagesCallback(unsigned int handle,
     return RULES_OK;
 }
 
-unsigned int setGetStoredMessagesCallback(unsigned int handle, 
-                                          void *context, 
-                                          unsigned int (*callback)(void *, char *, char *, char **)) {
-    ruleset *tree;
-    RESOLVE_HANDLE(handle, &tree);
-
-    tree->getStoredMessagesCallbackContext = context;
-    tree->getStoredMessagesCallback = callback;
-    return RULES_OK;
-}
-
 unsigned int setGetIdleStateCallback(unsigned int handle, 
                                      void *context, 
-                                     unsigned int (*callback)(void *, char *, char **)) {
+                                     unsigned int (*callback)(void *, char *)) {
     ruleset *tree;
     RESOLVE_HANDLE(handle, &tree);
 

data/src/rules/rete.h

@@ -157,13 +157,10 @@ typedef struct ruleset {
     unsigned int (*queueMessageCallback)(void *, char *, char *, unsigned char, char *);
     void *queueMessageCallbackContext;
     
-    unsigned int (*getQueuedMessagesCallback)(void *, char *, char *, char **);
+    unsigned int (*getQueuedMessagesCallback)(void *, char *, char *);
     void *getQueuedMessagesCallbackContext;
     
-    unsigned int (*getStoredMessagesCallback)(void *, char *, char *, char **);
-    void *getStoredMessagesCallbackContext;
-
-    unsigned int (*getIdleStateCallback)(void *, char *, char **);
+    unsigned int (*getIdleStateCallback)(void *, char *);
     void *getIdleStateCallbackContext;
 
 

data/src/rules/rules.h

@@ -109,9 +109,6 @@ extern char entriesInitialized;
     if (!firstEmptyEntry) firstEmptyEntry = lastEmptyEntry; \
 } while(0)
 
-
-unsigned int cloneString(char **target, char *source);
-
 unsigned int createRuleset(unsigned int *handle, 
                            char *name, 
                            char *rules);
@@ -130,15 +127,19 @@ unsigned int setQueueMessageCallback(unsigned int handle,
 
 unsigned int setGetQueuedMessagesCallback(unsigned int handle, 
                                           void *context, 
-                                          unsigned int (*callback)(void *, char *, char *, char **));
+                                          unsigned int (*callback)(void *, char *, char *));
 
-unsigned int setGetStoredMessagesCallback(unsigned int handle, 
-                                          void *context, 
-                                          unsigned int (*callback)(void *, char *, char *, char **));
+unsigned int completeGetQueuedMessages(unsigned int handle,
+                                       char *sid,
+                                       char *queuedMessages);
 
 unsigned int setGetIdleStateCallback(unsigned int handle, 
                                      void *context, 
-                                     unsigned int (*callback)(void *, char *, char **));
+                                     unsigned int (*callback)(void *, char *));
+
+unsigned int completeGetIdleState(unsigned int handle, 
+                                  char *sid, 
+                                  char *storedMessages);
 
 unsigned int deleteRuleset(unsigned int handle);
 

data/src/rules/state.c

@@ -154,17 +154,6 @@ int asprintf(char** ret, char* format, ...){
     --pool.count; \
 } while (0)
 
-unsigned int cloneString(char **target, char *source) {
-    unsigned int length = (strlen(source) + 1) * sizeof(char);
-    *target = malloc(length);
-    if (!*target) {
-        return ERR_OUT_OF_MEMORY;
-    }
-    memcpy(*target, source, length);
-
-    return RULES_OK;
-}
-
 unsigned int fnv1Hash32(char *str, unsigned int length) {
     unsigned int hash = FNV_32_OFFSET_BASIS;
     for(unsigned int i = 0; i < length; str++, i++) {
@@ -750,6 +739,7 @@ unsigned int storeMessage(void *tree,
                           char *mid,
                           jsonObject *message,
                           unsigned char messageType,
+                          unsigned char sideEffect,
                           unsigned int *valueOffset) {
     unsigned int hash = fnv1Hash32(mid, strlen(mid));
     *valueOffset = UNDEFINED_HASH_OFFSET;
@@ -787,12 +777,20 @@ unsigned int storeMessage(void *tree,
     CHECK_RESULT(copyMessage(&node->jo, message));
 
     ruleset *rulesetTree = (ruleset*)tree;
-    if (rulesetTree->storeMessageCallback) {
-        unsigned char actionType = ACTION_ASSERT_FACT;
-        if (messageType == MESSAGE_TYPE_EVENT) {
-            actionType = ACTION_ASSERT_EVENT;
+    if (sideEffect && rulesetTree->storeMessageCallback) {
+        unsigned char actionType;
+        switch (messageType) {
+            case MESSAGE_TYPE_EVENT:
+                actionType = ACTION_ASSERT_EVENT;
+                break;
+            case MESSAGE_TYPE_FACT:
+                actionType = ACTION_ASSERT_FACT;
+                break;
+            case MESSAGE_TYPE_STATE:
+                actionType = ACTION_UPDATE_STATE;
+                break;
         }
-
+        
         return rulesetTree->storeMessageCallback(rulesetTree->storeMessageCallbackContext, 
                                                  &rulesetTree->stringPool[rulesetTree->nameOffset],
                                                  state->sid, 

data/src/rules/state.h

@@ -9,6 +9,7 @@
 
 #define MESSAGE_TYPE_EVENT 0
 #define MESSAGE_TYPE_FACT 1
+#define MESSAGE_TYPE_STATE 2
 
 #define ACTION_ASSERT_FACT 1
 #define ACTION_ASSERT_EVENT 2
@@ -326,6 +327,7 @@ unsigned int storeMessage(void *tree,
                           char *mid,
                           jsonObject *message,
                           unsigned char messageType,
+                          unsigned char sideEffect,
                           unsigned int *valueOffset);
 
 unsigned int getStateNode(void *tree, 

metadata

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