durable_rules 2.0.5 → 2.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f2783f44507366a2029205429dd94b99da4fdb8
-  data.tar.gz: 15e4d147d321f18e701583d1cb0f1a77dac4a977
+  metadata.gz: c4dd49e4357fbd2d4df00d1055d3f28413f81631
+  data.tar.gz: 8f27a057991ac417017ad5127a2161a0be2accd8
 SHA512:
-  metadata.gz: 73533cb05af0e9d0a5190187f5636e49fcbe000e7c2f374d3d142d20a998a94f22016a4570f1623e4809c8698d2d1a403afc1ca5aa2879a991998f2b93fa36d5
-  data.tar.gz: 9ba5938a86bb9737246f6779a9d499f06eb116b2d079d5b2ac521769cbfde26b220c4dd68af14e12d1e5238927d155518e714aed5764d3b7a0e65dc8a06726a2
+  metadata.gz: a8c5ad57d5aa1cbdc2b798dfc2c91bab920d127b4ac05190c5a61a2eada58dc2261ee6bf062078ad1c7a4aa42e82e338b2580646ea5f3accefe8459f54063777
+  data.tar.gz: baa4b3ac0b646cf45cd427df314d015dc6a76d3d5d34b6126e2bc24cce39d971b43f540171422e7a874faa896d69573d8a6bba4f7baf5b1cf8e2861ead5d4473

data/src/rules/events.c

@@ -13,13 +13,6 @@
 #include "regex.h"
 #include "rete.h"
 
-#define ACTION_ASSERT_FACT 1
-#define ACTION_ASSERT_EVENT 2
-#define ACTION_RETRACT_FACT 3
-#define ACTION_RETRACT_EVENT 4
-#define ACTION_UPDATE_STATE 5
-
-
 #define MAX_RESULT_NODES 32
 #define MAX_NODE_RESULTS 16
 #define MAX_STACK_SIZE 64
@@ -998,6 +991,7 @@ static unsigned int handleBetaFrame(ruleset *tree,
 
 static unsigned int handleDeleteMessage(ruleset *tree,
                                         stateNode *state,
+                                        char *mid,
                                         unsigned int messageOffset) {
     unsigned int result;
     unsigned int count = 0;
@@ -1139,7 +1133,10 @@ static unsigned int handleDeleteMessage(ruleset *tree,
         }
     }
 
-    result = deleteMessage(state, messageOffset);
+    result = deleteMessage(tree, 
+                           state,
+                           mid, 
+                           messageOffset);
     if (result == ERR_NODE_DELETED) {
         return RULES_OK;
     } else if (result != RULES_OK) {
@@ -1590,14 +1587,17 @@ static unsigned int handleAlpha(ruleset *tree,
                                 stateNode *state,
                                 char *mid,
                                 jsonObject *jo,
-                                unsigned int currentMessageOffset,
-                                alpha *alphaNode) { 
+                                unsigned char messageType,
+                                alpha *alphaNode, 
+                                unsigned int *messageOffset) { 
     unsigned short top = 1;
     unsigned int entry;
+    unsigned char messageStored = 0;
     alpha *stack[MAX_STACK_SIZE];
     stack[0] = alphaNode;
     alpha *currentAlpha;
     unsigned int result = ERR_EVENT_NOT_HANDLED;
+    *messageOffset = UNDEFINED_HASH_OFFSET;
 
     while (top) {
         --top;
@@ -1665,6 +1665,17 @@ static unsigned int handleAlpha(ruleset *tree,
         }
 
         if (currentAlpha->betaListOffset) {
+            if (!messageStored) {
+                CHECK_RESULT(storeMessage(tree,
+                                          state,
+                                          mid,
+                                          jo,
+                                          messageType,
+                                          messageOffset));
+
+                messageStored = 1;
+            }
+
             result = RULES_OK;
             unsigned int *betaList = &tree->nextPool[currentAlpha->betaListOffset];
             for (unsigned int entry = 0; betaList[entry] != 0; ++entry) {
@@ -1672,7 +1683,7 @@ static unsigned int handleAlpha(ruleset *tree,
                                                state, 
                                                &tree->nodePool[betaList[entry]],
                                                jo,
-                                               currentMessageOffset));
+                                               *messageOffset));
             }
         }
     }
@@ -1702,7 +1713,7 @@ static unsigned int handleMessageCore(ruleset *tree,
 
     sid[sidProperty->valueLength] = '\0';
 
-    #ifdef _WIN32
+#ifdef _WIN32
     char *mid = (char *)_alloca(sizeof(char)*(midProperty->valueLength + 1));
 #else
     char mid[midProperty->valueLength + 1];
@@ -1713,38 +1724,59 @@ static unsigned int handleMessageCore(ruleset *tree,
         strncpy(mid, jo->idBuffer, midProperty->valueLength);
     }
 
+    *stateOffset = UNDEFINED_HASH_OFFSET;
     mid[midProperty->valueLength] = '\0';
-    unsigned char isNewState;
-    CHECK_RESULT(ensureStateNode(tree, 
-                                 sid,
-                                 &isNewState, 
-                                 &sidState));
+    unsigned int result = getStateNode(tree, 
+                                       sid,
+                                       &sidState);
+    if (result != RULES_OK && result != ERR_SID_NOT_FOUND) {
+        return result;
+    } else if (result == ERR_SID_NOT_FOUND) {
+        if (!tree->queueMessageCallback) {
+            CHECK_RESULT(createStateNode(tree, 
+                                         sid,
+                                         &sidState));
+        } else {
+            CHECK_RESULT(tree->queueMessageCallback(tree->queueMessageCallbackContext,
+                                                    &tree->stringPool[tree->nameOffset],
+                                                    sid,
+                                                    actionType,
+                                                    jo->content));
+
+            return ERR_EVENT_DEFERRED;
+        }
+    } 
 
     *stateOffset = sidState->offset;
     if (actionType == ACTION_UPDATE_STATE) {
         if (sidState->factOffset != UNDEFINED_HASH_OFFSET) {
             CHECK_RESULT(handleDeleteMessage(tree,
                                              sidState,
+                                             mid,
                                              sidState->factOffset));
 
         }
 
-        CHECK_RESULT(storeMessage(sidState,
+        result = handleAlpha(tree,
+                             sidState,
+                             mid,
+                             jo,
+                             MESSAGE_TYPE_FACT,
+                             &tree->nodePool[NODE_M_OFFSET].value.a,
+                             messageOffset);
+        if (result != RULES_OK && result != ERR_EVENT_NOT_HANDLED) {
+            return result;
+        } else if (result == ERR_EVENT_NOT_HANDLED) {
+            CHECK_RESULT(storeMessage(tree,
+                                  sidState,
                                   mid,
                                   jo,
                                   MESSAGE_TYPE_FACT,
                                   messageOffset));
-
+        }
 
         sidState->factOffset = *messageOffset;
-        CHECK_RESULT(handleAlpha(tree,
-                                 sidState,
-                                 mid,
-                                 jo,
-                                 sidState->factOffset,
-                                 &tree->nodePool[NODE_M_OFFSET].value.a));
-
-    } else if (actionType == ACTION_RETRACT_FACT || actionType == ACTION_RETRACT_EVENT) {
+    } else if (actionType == ACTION_RETRACT_FACT) {
         CHECK_RESULT(getMessage(sidState,
                                 mid,
                                 messageOffset));
@@ -1752,24 +1784,20 @@ static unsigned int handleMessageCore(ruleset *tree,
         if (*messageOffset != UNDEFINED_HASH_OFFSET) {
             CHECK_RESULT(handleDeleteMessage(tree,
                                              sidState,
+                                             mid,
                                              *messageOffset));
         }
     } else {
-        CHECK_RESULT(storeMessage(sidState,
-                                  mid,
-                                  jo,
-                                  (actionType == ACTION_ASSERT_FACT ? MESSAGE_TYPE_FACT : MESSAGE_TYPE_EVENT),
-                                  messageOffset));
-
         unsigned int result = handleAlpha(tree,
                                           sidState,
                                           mid,
                                           jo,
-                                          *messageOffset,
-                                          &tree->nodePool[NODE_M_OFFSET].value.a);
+                                          (actionType == ACTION_ASSERT_FACT ? MESSAGE_TYPE_FACT : MESSAGE_TYPE_EVENT),
+                                          &tree->nodePool[NODE_M_OFFSET].value.a,
+                                          messageOffset);
 
         if (result == RULES_OK || result == ERR_EVENT_NOT_HANDLED) {
-            if (isNewState) {      
+            if (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);
@@ -1781,7 +1809,7 @@ static unsigned int handleMessageCore(ruleset *tree,
                 unsigned int stateMessageOffset;
                 unsigned int stateResult = handleMessage(tree,
                                                          stateMessage,  
-                                                         ACTION_ASSERT_FACT,
+                                                         ACTION_UPDATE_STATE,
                                                          &stateMessageOffset,
                                                          stateOffset);
                 if (stateResult != RULES_OK && stateResult != ERR_EVENT_NOT_HANDLED) {
@@ -1861,12 +1889,12 @@ static unsigned int handleMessages(ruleset *tree,
                                    stateOffset);
         
         *last = lastTemp;
-        if (result != RULES_OK && result != ERR_EVENT_NOT_HANDLED) {
+        if (result != RULES_OK && result != ERR_EVENT_NOT_HANDLED && result != ERR_EVENT_OBSERVED) {
             return result;
         }
 
-        if (result == ERR_EVENT_NOT_HANDLED) {
-            returnResult = ERR_EVENT_NOT_HANDLED;
+        if (result == ERR_EVENT_NOT_HANDLED || result == ERR_EVENT_OBSERVED) {
+            returnResult = result;
         }
        
         first = last;
@@ -1949,6 +1977,149 @@ unsigned int updateState(unsigned int handle,
     return result;
 }
 
+static unsigned int replayMessages(ruleset *tree, 
+                                   char *messages, 
+                                   unsigned int *stateOffset) {
+    unsigned int result;
+    unsigned int messageOffset;
+    jsonObject jo;
+    unsigned char type;
+    unsigned char actionType;
+    char *first = messages;
+    char *last = NULL;
+    char lastTemp;
+    
+    while (readNextArrayValue(first, 
+                         &first, 
+                         &last, 
+                         &type) == PARSE_OK) {
+
+        if (type != JSON_INT) {
+            return ERR_UNEXPECTED_TYPE;
+        }
+
+        char temp = last[1];
+        last[1] = '\0';
+        actionType = atol(first);
+        last[1] = temp;
+        first = last;
+
+        CHECK_PARSE_RESULT(readNextArrayValue(first, 
+                                             &first, 
+                                             &last, 
+                                             &type));
+
+        if (type != JSON_OBJECT) {
+            return ERR_UNEXPECTED_TYPE;
+        }
+        
+        CHECK_RESULT(constructObject(first,
+                                     NULL, 
+                                     NULL, 
+                                     1,
+                                     &jo,
+                                     &last));
+
+        while (*last != ',' && *last != '\0' ) {
+            ++last;
+        }
+
+        if (*last == '\0') {
+            --last;
+        }
+
+        lastTemp = *last;
+        *last = '\0';
+        result = handleMessageCore(tree,
+                                   &jo, 
+                                   actionType, 
+                                   &messageOffset,
+                                   stateOffset);
+        
+        *last = lastTemp;
+        if (result != RULES_OK && result != ERR_EVENT_NOT_HANDLED && result != ERR_EVENT_OBSERVED) {
+            return result;
+        }
+       
+        first = last;
+    }
+
+    return RULES_OK;
+}
+
+
+static unsigned int flushQueuedActions(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;
+                    }
+                    
+                }
+            }
+        }
+    }
+
+
+    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;
+                }
+            }
+        }
+    }
+
+    return RULES_OK;
+}
+
 unsigned int startAction(unsigned int handle, 
                          char **stateFact, 
                          char **messages, 
@@ -1962,6 +2133,8 @@ unsigned int startAction(unsigned int handle,
     unsigned int resultFrameOffset;
     time_t currentTime = time(NULL);
 
+    CHECK_RESULT(flushQueuedActions(tree));  
+
     CHECK_RESULT(getNextResult(tree,
                                currentTime,
                                &resultState, 
@@ -1995,6 +2168,11 @@ unsigned int startActionForState(unsigned int handle,
                                  unsigned int stateOffset,
                                  char **stateFact,
                                  char **messages) {
+
+    if (stateOffset == UNDEFINED_HASH_OFFSET) {
+        return ERR_NO_ACTION_AVAILABLE;
+    }
+
     ruleset *tree;
     RESOLVE_HANDLE(handle, &tree);
     stateNode *resultState = STATE_NODE(tree, stateOffset);
@@ -2052,10 +2230,26 @@ static unsigned int deleteCurrentAction(ruleset *tree,
                 messageNode *currentMessageNode = MESSAGE_NODE(state, 
                                                                currentMessageFrame->messageNodeOffset);
 
-
                 if (currentMessageNode->messageType == MESSAGE_TYPE_EVENT) {
+                    jsonObject *jo = &currentMessageNode->jo;
+                    jsonProperty *midProperty = &jo->properties[jo->idIndex];
+
+#ifdef _WIN32
+                    char *mid = (char *)_alloca(sizeof(char)*(midProperty->valueLength + 1));
+#else
+                    char mid[midProperty->valueLength + 1];
+#endif
+                    if (midProperty->valueOffset) {
+                        strncpy(mid, jo->content + midProperty->valueOffset, midProperty->valueLength);
+                    } else {
+                        strncpy(mid, jo->idBuffer, midProperty->valueLength);
+                    }
+
+                    mid[midProperty->valueLength] = '\0';
+
                     CHECK_RESULT(handleDeleteMessage(tree,
-                                                     state, 
+                                                     state,
+                                                     mid, 
                                                      currentMessageFrame->messageNodeOffset));
                 }
             }
@@ -2091,7 +2285,6 @@ unsigned int completeAndStartAction(unsigned int handle,
     ruleset *tree;
     RESOLVE_HANDLE(handle, &tree);
     stateNode *resultState = STATE_NODE(tree, stateOffset);
-    
     CHECK_RESULT(deleteCurrentAction(tree,
                                      resultState, 
                                      resultState->context.actionStateIndex,
@@ -2138,7 +2331,6 @@ unsigned int abandonAction(unsigned int handle, unsigned int stateOffset) {
 
 unsigned int renewActionLease(unsigned int handle, char *sid) {
     ruleset *tree;
-    unsigned char isNewState;
     stateNode *state = NULL;
 
     RESOLVE_HANDLE(handle, &tree);
@@ -2146,10 +2338,9 @@ unsigned int renewActionLease(unsigned int handle, char *sid) {
         sid = "0";
     }
 
-    CHECK_RESULT(ensureStateNode(tree, 
-                                 sid,
-                                 &isNewState,
-                                 &state));    
+    CHECK_RESULT(getStateNode(tree, 
+                              sid,
+                              &state));    
 
     state->lockExpireTime = time(NULL) + STATE_LEASE_TIME;
     return RULES_OK;
@@ -2209,7 +2400,6 @@ unsigned int assertTimers(unsigned int handle) {
 
 unsigned int cancelTimer(unsigned int handle, char *sid, char *timerName) {
     ruleset *tree;
-    unsigned char isNewState;
     unsigned int messageOffset;
     unsigned int stateOffset;
     stateNode *state = NULL;
@@ -2219,10 +2409,9 @@ unsigned int cancelTimer(unsigned int handle, char *sid, char *timerName) {
         sid = "0";
     }
 
-    CHECK_RESULT(ensureStateNode(tree, 
-                                 sid,
-                                 &isNewState, 
-                                 &state));
+    CHECK_RESULT(getStateNode(tree, 
+                              sid,
+                              &state));
 
     CHECK_RESULT(getMessage(state,
                             timerName,

data/src/rules/rete.c

@@ -1852,6 +1852,19 @@ unsigned int createRuleset(unsigned int *handle, char *name, char *rules) {
     tree->actionCount = 0;
     tree->bindingsList = NULL;
     tree->currentStateIndex = 0;
+    tree->storeMessageCallback = NULL;
+    tree->storeMessageCallbackContext = NULL;
+    tree->deleteMessageCallback = NULL;
+    tree->deleteMessageCallbackContext = NULL;
+    tree->queueMessageCallback = NULL;
+    tree->queueMessageCallbackContext = NULL;
+    tree->getQueuedMessagesCallback = NULL;
+    tree->getQueuedMessagesCallbackContext = NULL;
+    tree->getStoredMessagesCallback = NULL;
+    tree->getStoredMessagesCallbackContext = NULL;
+    tree->getIdleStateCallback = NULL;
+    tree->getIdleStateCallbackContext = NULL;
+
     memset(tree->stateIndex, 0, MAX_STATE_INDEX_LENGTH * sizeof(unsigned int) * 2);
     memset(tree->reverseStateIndex, 0, MAX_STATE_INDEX_LENGTH * sizeof(unsigned int));
     initStatePool(tree);
@@ -1894,4 +1907,66 @@ unsigned int deleteRuleset(unsigned int handle) {
     return RULES_OK;
 }
 
+unsigned int setStoreMessageCallback(unsigned int handle, 
+                                     void *context, 
+                                     unsigned int (*callback)(void *, char *, char *, char *, unsigned char, char *)) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+    tree->storeMessageCallbackContext = context;
+    tree->storeMessageCallback = callback;
+    return RULES_OK;
+}
+
+unsigned int setDeleteMessageCallback(unsigned int handle, 
+                                      void *context,
+                                      unsigned int (*callback)(void *, char *, char *, char *)) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+    tree->deleteMessageCallbackContext = context;
+    tree->deleteMessageCallback = callback;    
+    return RULES_OK;
+}
+
+unsigned int setQueueMessageCallback(unsigned int handle, 
+                                     void *context, 
+                                     unsigned int (*callback)(void *, char *, char *, unsigned char, char *)) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+    tree->queueMessageCallbackContext = context;
+    tree->queueMessageCallback = callback;
+    return RULES_OK;
+}
+
+unsigned int setGetQueuedMessagesCallback(unsigned int handle, 
+                                          void *context, 
+                                          unsigned int (*callback)(void *, char *, char *, char **)) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    tree->getQueuedMessagesCallbackContext = context;
+    tree->getQueuedMessagesCallback = callback;
+    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 **)) {
+    ruleset *tree;
+    RESOLVE_HANDLE(handle, &tree);
+
+    tree->getIdleStateCallbackContext = context;
+    tree->getIdleStateCallback = callback;
+    return RULES_OK;
+}
 

data/src/rules/rete.h

@@ -146,6 +146,27 @@ typedef struct ruleset {
     unsigned int stateIndex[MAX_STATE_INDEX_LENGTH];
     unsigned int reverseStateIndex[MAX_STATE_INDEX_LENGTH];
     unsigned int currentStateIndex;
+
+
+    unsigned int (*storeMessageCallback)(void *, char *, char *, char *, unsigned char, char *);
+    void *storeMessageCallbackContext;
+    
+    unsigned int (*deleteMessageCallback)(void *, char *, char *, char *);
+    void *deleteMessageCallbackContext;
+    
+    unsigned int (*queueMessageCallback)(void *, char *, char *, unsigned char, char *);
+    void *queueMessageCallbackContext;
+    
+    unsigned int (*getQueuedMessagesCallback)(void *, char *, char *, char **);
+    void *getQueuedMessagesCallbackContext;
+    
+    unsigned int (*getStoredMessagesCallback)(void *, char *, char *, char **);
+    void *getStoredMessagesCallbackContext;
+
+    unsigned int (*getIdleStateCallback)(void *, char *, char **);
+    void *getIdleStateCallbackContext;
+
+
 } ruleset;
 
 #ifdef _PRINT

data/src/rules/rules.h

@@ -2,6 +2,7 @@
 #define RULES_OK 0
 #define ERR_EVENT_NOT_HANDLED 1
 #define ERR_EVENT_OBSERVED 2
+#define ERR_EVENT_DEFERRED 3
 
 #define ERR_OUT_OF_MEMORY 101
 #define ERR_UNEXPECTED_TYPE 102
@@ -108,10 +109,37 @@ 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);
 
+unsigned int setStoreMessageCallback(unsigned int handle, 
+                                     void *context, 
+                                     unsigned int (*callback)(void *, char *, char *, char *, unsigned char, char *));
+
+unsigned int setDeleteMessageCallback(unsigned int handle, 
+                                      void *context,
+                                      unsigned int (*callback)(void *, char *, char *, char *));
+
+unsigned int setQueueMessageCallback(unsigned int handle, 
+                                     void *context, 
+                                     unsigned int (*callback)(void *, char *, char *, unsigned char, char *));
+
+unsigned int setGetQueuedMessagesCallback(unsigned int handle, 
+                                          void *context, 
+                                          unsigned int (*callback)(void *, char *, char *, char **));
+
+unsigned int setGetStoredMessagesCallback(unsigned int handle, 
+                                          void *context, 
+                                          unsigned int (*callback)(void *, char *, char *, char **));
+
+unsigned int setGetIdleStateCallback(unsigned int handle, 
+                                     void *context, 
+                                     unsigned int (*callback)(void *, char *, char **));
+
 unsigned int deleteRuleset(unsigned int handle);
 
 unsigned int createClient(unsigned int *handle, 

data/src/rules/state.c

@@ -154,6 +154,17 @@ 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++) {
@@ -670,10 +681,19 @@ unsigned int createRightFrame(stateNode *state,
     return RULES_OK;
 }
 
-unsigned int deleteMessage(stateNode *state,
+unsigned int deleteMessage(void *tree,
+                           stateNode *state,
+                           char *mid,
                            unsigned int messageNodeOffset) {
-
     messageNode *node = MESSAGE_NODE(state, messageNodeOffset);
+    ruleset *rulesetTree = (ruleset*)tree;
+    if (rulesetTree->deleteMessageCallback) {
+        CHECK_RESULT(rulesetTree->deleteMessageCallback(rulesetTree->deleteMessageCallbackContext,
+                                                        &rulesetTree->stringPool[rulesetTree->nameOffset],
+                                                        state->sid, 
+                                                        mid));
+    }
+
     if (node->jo.content) {
         free(node->jo.content);
         free(node->locationPool.content);
@@ -686,6 +706,7 @@ unsigned int deleteMessage(stateNode *state,
            MAX_MESSAGE_INDEX_LENGTH,
            state->messagePool,
            messageNodeOffset);
+
     return RULES_OK;
 }
 
@@ -724,7 +745,8 @@ static unsigned int copyMessage(jsonObject *targetMessage,
     return RULES_OK;
 }
 
-unsigned int storeMessage(stateNode *state,
+unsigned int storeMessage(void *tree,
+                          stateNode *state,
                           char *mid,
                           jsonObject *message,
                           unsigned char messageType,
@@ -762,13 +784,29 @@ unsigned int storeMessage(stateNode *state,
     memset(node->locationIndex, 0, MAX_LOCATION_INDEX_LENGTH * sizeof(unsigned int) * 2);
 
     node->messageType = messageType;
-    return copyMessage(&node->jo, message);
+    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;
+        }
+
+        return rulesetTree->storeMessageCallback(rulesetTree->storeMessageCallbackContext, 
+                                                 &rulesetTree->stringPool[rulesetTree->nameOffset],
+                                                 state->sid, 
+                                                 mid, 
+                                                 actionType,
+                                                 message->content);
+    }
+
+    return RULES_OK;
 }
 
-unsigned int ensureStateNode(void *tree, 
-                             char *sid, 
-                             unsigned char *isNew,
-                             stateNode **state) {  
+unsigned int getStateNode(void *tree, 
+                          char *sid, 
+                          stateNode **state) { 
     unsigned int sidHash = fnv1Hash32(sid, strlen(sid));
     unsigned int nodeOffset;
     ruleset *rulesetTree = (ruleset*)tree;
@@ -779,102 +817,144 @@ unsigned int ensureStateNode(void *tree,
               ((ruleset*)tree)->statePool, 
               sidHash, 
               nodeOffset);
+    if (nodeOffset == UNDEFINED_HASH_OFFSET) {
+      return ERR_SID_NOT_FOUND;
+    }
 
-    if (nodeOffset != UNDEFINED_HASH_OFFSET) {
-        *isNew = 0;
-        *state = STATE_NODE(tree, nodeOffset); 
-    } else {
-        *isNew = 1;
-        NEW(stateNode, 
-            rulesetTree->statePool, 
-            nodeOffset);
-
-        SET(stateNode, 
-            rulesetTree->stateIndex, 
-            MAX_STATE_INDEX_LENGTH, 
-            rulesetTree->statePool, 
-            sidHash, 
-            nodeOffset);
-
-        if (rulesetTree->statePool.count > MAX_STATE_INDEX_LENGTH) {
-            return ERR_OUT_OF_MEMORY;
-        }
-        rulesetTree->reverseStateIndex[rulesetTree->statePool.count - 1] = nodeOffset;
-        stateNode *node = STATE_NODE(tree, nodeOffset); 
-        node->offset = nodeOffset;
+    *state = STATE_NODE(tree, nodeOffset); 
+    return RULES_OK; 
+} 
 
-        int sidLength = sizeof(char) * (strlen(sid) + 1);
-        node->sid = malloc(sidLength);
-        if (!node->sid) {
-            return ERR_OUT_OF_MEMORY;
-        }
-        memcpy(node->sid, sid, sidLength);
+unsigned int createStateNode(void *tree, 
+                             char *sid, 
+                             stateNode **state) {  
+    unsigned int sidHash = fnv1Hash32(sid, strlen(sid));
+    unsigned int nodeOffset;
+    ruleset *rulesetTree = (ruleset*)tree;
+
+    NEW(stateNode, 
+        rulesetTree->statePool, 
+        nodeOffset);
 
-        INIT(messageNode, 
-             node->messagePool, 
-             MAX_MESSAGE_NODES);
+    SET(stateNode, 
+        rulesetTree->stateIndex, 
+        MAX_STATE_INDEX_LENGTH, 
+        rulesetTree->statePool, 
+        sidHash, 
+        nodeOffset);
 
-        memset(node->messageIndex, 0, MAX_MESSAGE_INDEX_LENGTH * sizeof(unsigned int) * 2);
+    if (rulesetTree->statePool.count > MAX_STATE_INDEX_LENGTH) {
+        return ERR_OUT_OF_MEMORY;
+    }
+    rulesetTree->reverseStateIndex[rulesetTree->statePool.count - 1] = nodeOffset;
+    stateNode *node = STATE_NODE(tree, nodeOffset); 
+    node->offset = nodeOffset;
+
+    int sidLength = sizeof(char) * (strlen(sid) + 1);
+    node->sid = malloc(sidLength);
+    if (!node->sid) {
+        return ERR_OUT_OF_MEMORY;
+    }
+    memcpy(node->sid, sid, sidLength);
+
+    INIT(messageNode, 
+         node->messagePool, 
+         MAX_MESSAGE_NODES);
+
+    memset(node->messageIndex, 0, MAX_MESSAGE_INDEX_LENGTH * sizeof(unsigned int) * 2);
+    
+    node->betaState = malloc(((ruleset*)tree)->betaCount * sizeof(betaStateNode));
+    for (unsigned int i = 0; i < ((ruleset*)tree)->betaCount; ++i) {
+        betaStateNode *betaNode = &node->betaState[i];
+        betaNode->reteNode = NULL;
+
+        INIT(leftFrameNode, 
+             betaNode->leftFramePool, 
+             MAX_LEFT_FRAME_NODES);
+
+        memset(betaNode->leftFrameIndex, 0, MAX_LEFT_FRAME_INDEX_LENGTH * sizeof(unsigned int) * 2);
         
-        node->betaState = malloc(((ruleset*)tree)->betaCount * sizeof(betaStateNode));
-        for (unsigned int i = 0; i < ((ruleset*)tree)->betaCount; ++i) {
-            betaStateNode *betaNode = &node->betaState[i];
-            betaNode->reteNode = NULL;
-
-            INIT(leftFrameNode, 
-                 betaNode->leftFramePool, 
-                 MAX_LEFT_FRAME_NODES);
-
-            memset(betaNode->leftFrameIndex, 0, MAX_LEFT_FRAME_INDEX_LENGTH * sizeof(unsigned int) * 2);
-            
-            INIT(rightFrameNode, 
-                 betaNode->rightFramePool, 
-                 MAX_RIGHT_FRAME_NODES);
-
-            memset(betaNode->rightFrameIndex, 0, MAX_RIGHT_FRAME_INDEX_LENGTH * sizeof(unsigned int) * 2);
-        }
+        INIT(rightFrameNode, 
+             betaNode->rightFramePool, 
+             MAX_RIGHT_FRAME_NODES);
 
-        node->connectorState = malloc(((ruleset*)tree)->connectorCount * sizeof(connectorStateNode));
-        for (unsigned int i = 0; i < ((ruleset*)tree)->connectorCount; ++i) {
-            connectorStateNode *connectorNode = &node->connectorState[i];
-            connectorNode->reteNode = NULL;
+        memset(betaNode->rightFrameIndex, 0, MAX_RIGHT_FRAME_INDEX_LENGTH * sizeof(unsigned int) * 2);
+    }
 
-            INIT(leftFrameNode, 
-                 connectorNode->aFramePool, 
-                 MAX_LEFT_FRAME_NODES);
- 
-            connectorNode->aFrameIndex[0] = UNDEFINED_HASH_OFFSET;
-            connectorNode->aFrameIndex[1] = UNDEFINED_HASH_OFFSET;
+    node->connectorState = malloc(((ruleset*)tree)->connectorCount * sizeof(connectorStateNode));
+    for (unsigned int i = 0; i < ((ruleset*)tree)->connectorCount; ++i) {
+        connectorStateNode *connectorNode = &node->connectorState[i];
+        connectorNode->reteNode = NULL;
 
-            INIT(leftFrameNode, 
-                 connectorNode->bFramePool, 
-                 MAX_LEFT_FRAME_NODES);
+        INIT(leftFrameNode, 
+             connectorNode->aFramePool, 
+             MAX_LEFT_FRAME_NODES);
 
-            connectorNode->bFrameIndex[0] = UNDEFINED_HASH_OFFSET;
-            connectorNode->bFrameIndex[1] = UNDEFINED_HASH_OFFSET;
-        }
+        connectorNode->aFrameIndex[0] = UNDEFINED_HASH_OFFSET;
+        connectorNode->aFrameIndex[1] = UNDEFINED_HASH_OFFSET;
+
+        INIT(leftFrameNode, 
+             connectorNode->bFramePool, 
+             MAX_LEFT_FRAME_NODES);
 
-        node->actionState = malloc(((ruleset*)tree)->actionCount * sizeof(actionStateNode));
-        for (unsigned int i = 0; i < ((ruleset*)tree)->actionCount; ++i) {
-            actionStateNode *actionNode = &node->actionState[i];
-            actionNode->reteNode = NULL;
-            
-            actionNode->resultIndex[0] = UNDEFINED_HASH_OFFSET;
-            actionNode->resultIndex[1] = UNDEFINED_HASH_OFFSET;
-
-            INIT(leftFrameNode, 
-                 actionNode->resultPool, 
-                 MAX_LEFT_FRAME_NODES);
-        }        
-
-        node->factOffset = UNDEFINED_HASH_OFFSET;
-        node->lockExpireTime = 0;
-        *state = node;
+        connectorNode->bFrameIndex[0] = UNDEFINED_HASH_OFFSET;
+        connectorNode->bFrameIndex[1] = UNDEFINED_HASH_OFFSET;
     }
+
+    node->actionState = malloc(((ruleset*)tree)->actionCount * sizeof(actionStateNode));
+    for (unsigned int i = 0; i < ((ruleset*)tree)->actionCount; ++i) {
+        actionStateNode *actionNode = &node->actionState[i];
+        actionNode->reteNode = NULL;
+        
+        actionNode->resultIndex[0] = UNDEFINED_HASH_OFFSET;
+        actionNode->resultIndex[1] = UNDEFINED_HASH_OFFSET;
+
+        INIT(leftFrameNode, 
+             actionNode->resultPool, 
+             MAX_LEFT_FRAME_NODES);
+    }        
+
+    node->factOffset = UNDEFINED_HASH_OFFSET;
+    node->lockExpireTime = 0;
+    *state = node;
     
     return RULES_OK;
 }
 
+unsigned int deleteStateNode(void *tree, 
+                             stateNode *node) {
+    ruleset *rulesetTree = (ruleset*)tree;
+    free(node->sid);
+
+    for (unsigned int i = 0; i < rulesetTree->betaCount; ++i) {
+        betaStateNode *betaNode = &node->betaState[i];
+        free(betaNode->leftFramePool.content);
+        free(betaNode->rightFramePool.content);
+    }
+    free(node->betaState);
+
+    for (unsigned int i = 0; i < rulesetTree->connectorCount; ++i) {
+        connectorStateNode *connectorNode = &node->connectorState[i];
+        free(connectorNode->aFramePool.content);
+        free(connectorNode->bFramePool.content);
+    }
+    free(node->connectorState);
+
+    for (unsigned int i = 0; i < rulesetTree->actionCount; ++i) {
+        actionStateNode *actionNode = &node->actionState[i];
+        free(actionNode->resultPool.content);
+    }   
+    free(node->actionState);
+
+    DELETE(stateNode, 
+           rulesetTree->stateIndex, 
+           MAX_STATE_INDEX_LENGTH, 
+           rulesetTree->statePool, 
+           node->offset);
+
+    return RULES_OK;
+}
+
 static unsigned int getResultFrameLength(ruleset *tree, 
                                          stateNode *state, 
                                          leftFrameNode *frame) {
@@ -1466,6 +1546,8 @@ unsigned int getState(unsigned int handle, char *sid, char **state) {
     return serializeState(node, state);
 }
 
+
+
 unsigned int deleteState(unsigned int handle, char *sid) {
     ruleset *tree;
     RESOLVE_HANDLE(handle, &tree);
@@ -1488,33 +1570,5 @@ unsigned int deleteState(unsigned int handle, char *sid) {
     }
 
     stateNode *node = STATE_NODE(tree, nodeOffset); 
-    free(node->sid);
-
-    for (unsigned int i = 0; i < ((ruleset*)tree)->betaCount; ++i) {
-        betaStateNode *betaNode = &node->betaState[i];
-        free(betaNode->leftFramePool.content);
-        free(betaNode->rightFramePool.content);
-    }
-    free(node->betaState);
-
-    for (unsigned int i = 0; i < ((ruleset*)tree)->connectorCount; ++i) {
-        connectorStateNode *connectorNode = &node->connectorState[i];
-        free(connectorNode->aFramePool.content);
-        free(connectorNode->bFramePool.content);
-    }
-    free(node->connectorState);
-
-    for (unsigned int i = 0; i < ((ruleset*)tree)->actionCount; ++i) {
-        actionStateNode *actionNode = &node->actionState[i];
-        free(actionNode->resultPool.content);
-    }   
-    free(node->actionState);
-
-    DELETE(stateNode, 
-           tree->stateIndex, 
-           MAX_STATE_INDEX_LENGTH, 
-           tree->statePool, 
-           nodeOffset);
-
-    return RULES_OK;
+    return deleteStateNode(tree, node);
 }

data/src/rules/state.h

@@ -10,6 +10,11 @@
 #define MESSAGE_TYPE_EVENT 0
 #define MESSAGE_TYPE_FACT 1
 
+#define ACTION_ASSERT_FACT 1
+#define ACTION_ASSERT_EVENT 2
+#define ACTION_RETRACT_FACT 3
+#define ACTION_UPDATE_STATE 4
+
 #define UNDEFINED_HASH_OFFSET 0
 #define MAX_OBJECT_PROPERTIES 32
 #define MAX_MESSAGE_FRAMES 16
@@ -307,24 +312,33 @@ unsigned int createActionFrame(stateNode *state,
                                leftFrameNode **newNode,
                                frameLocation *newLocation);
 
-unsigned int deleteMessage(stateNode *state,
+unsigned int deleteMessage(void *tree,
+                           stateNode *state,
+                           char *mid,
                            unsigned int messageNodeOffset);
 
 unsigned int getMessage(stateNode *state,
                         char *mid,
                         unsigned int *valueOffset);
 
-unsigned int storeMessage(stateNode *state,
+unsigned int storeMessage(void *tree,
+                          stateNode *state,
                           char *mid,
                           jsonObject *message,
                           unsigned char messageType,
                           unsigned int *valueOffset);
 
-unsigned int ensureStateNode(void *tree, 
+unsigned int getStateNode(void *tree, 
+                          char *sid, 
+                          stateNode **state);
+
+unsigned int createStateNode(void *tree, 
                              char *sid, 
-                             unsigned char *isNew,
                              stateNode **state);
 
+unsigned int deleteStateNode(void *tree, 
+                             stateNode *state);
+
 unsigned int serializeResult(void *tree, 
                              stateNode *state, 
                              actionStateNode *actionNode, 

metadata

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