durable_rules 0.31.1

data/src/rules/rete.h

@@ -0,0 +1,133 @@
+#include "state.h"
+
+#define OP_NOP 0
+#define OP_LT 0x01
+#define OP_LTE 0x02
+#define OP_GT 0x03
+#define OP_GTE 0x04
+#define OP_EQ 0x05
+#define OP_NEQ 0x06
+#define OP_EX 0x07
+#define OP_NEX 0x08
+#define OP_ALL 0x09
+#define OP_ANY 0x0A
+#define OP_OR 0x0B
+#define OP_AND 0x0C
+#define OP_END 0x0D
+#define OP_ADD 0x0E
+#define OP_SUB 0x0F
+#define OP_MUL 0x10
+#define OP_DIV 0x11
+#define OP_TYPE 0x12
+#define OP_NOT 0x13
+
+#define NODE_ALPHA 0
+#define NODE_BETA_CONNECTOR 1
+#define NODE_ACTION 2
+#define NODE_M_OFFSET 0
+
+typedef struct reference {
+    unsigned int hash;
+    unsigned int nameOffset;
+    unsigned int idOffset;
+} reference;
+
+typedef struct jsonValue {
+    unsigned char type;
+    union { 
+        long i; 
+        double d; 
+        unsigned char b; 
+        unsigned int stringOffset;
+        unsigned int idiomOffset;
+        reference property;
+    } value;
+} jsonValue;
+
+typedef struct idiom {
+    unsigned char operator;
+    jsonValue left;
+    jsonValue right; 
+} idiom;
+
+typedef struct expression {
+    unsigned int nameOffset;
+    unsigned int aliasOffset;
+    unsigned short termsLength;
+    unsigned char not;
+    union {
+        unsigned int termsOffset; 
+        unsigned int *termsPointer;
+    } t;
+} expression;
+
+typedef struct join {
+    unsigned int expressionsOffset;
+    unsigned short expressionsLength;
+} join;
+
+typedef struct alpha {
+    unsigned int hash;
+    unsigned char operator;
+    unsigned int betaListOffset;
+    unsigned int nextListOffset;
+    unsigned int nextOffset;
+    jsonValue right;
+} alpha;
+
+typedef struct betaConnector {
+    unsigned int hash;
+    unsigned int nextOffset;
+    unsigned char not;
+} betaConnector;
+
+typedef struct action {
+    unsigned int index;
+    unsigned short span;
+    unsigned short count;
+    unsigned short cap;
+    unsigned int partitionBy;
+    unsigned short priority;
+    unsigned int joinsOffset;
+    unsigned short joinsLength;
+} action;
+
+typedef struct node {
+    unsigned int nameOffset;
+    unsigned char type;
+    union { 
+        alpha a; 
+        betaConnector b; 
+        action c; 
+    } value;
+} node;
+
+typedef struct ruleset {
+    unsigned int nameOffset;
+    node *nodePool;
+    unsigned int nodeOffset;
+    unsigned int *nextPool;
+    unsigned int nextOffset;
+    char *stringPool;
+    unsigned int stringPoolLength; 
+    expression *expressionPool;
+    unsigned int expressionOffset;
+    idiom *idiomPool;
+    unsigned int idiomOffset;
+    join *joinPool;
+    unsigned int joinOffset;
+    unsigned int actionCount;
+    void *bindingsList;
+    unsigned int *stateBuckets;
+    unsigned int stateBucketsLength;
+    stateEntry *state; 
+    unsigned int maxStateLength;
+    unsigned int stateLength;
+    unsigned int lruStateOffset;
+    unsigned int mruStateOffset;
+    unsigned int orNodeOffset;
+    unsigned int andNodeOffset;
+    unsigned int endNodeOffset;
+} ruleset;
+
+

data/src/rules/rules.h

@@ -0,0 +1,171 @@
+
+#define RULES_OK 0
+#define ERR_OUT_OF_MEMORY 1
+#define ERR_UNEXPECTED_TYPE 2
+#define ERR_IDENTIFIER_LENGTH 3  
+#define ERR_UNEXPECTED_VALUE 4 
+#define ERR_UNEXPECTED_NAME 5 
+#define ERR_RULE_LIMIT_EXCEEDED 6 
+#define ERR_RULE_EXISTS_LIMIT_EXCEEDED 7 
+#define ERR_RULE_BETA_LIMIT_EXCEEDED 8
+#define ERR_RULE_WITHOUT_QUALIFIER 9
+#define ERR_SETTING_NOT_FOUND 10
+#define ERR_PARSE_VALUE 101
+#define ERR_PARSE_STRING 102
+#define ERR_PARSE_NUMBER 103
+#define ERR_PARSE_OBJECT 104
+#define ERR_PARSE_ARRAY 105
+#define ERR_EVENT_NOT_HANDLED 201
+#define ERR_EVENT_MAX_PROPERTIES 202
+#define ERR_MAX_STACK_SIZE 203
+#define ERR_NO_ID_DEFINED 204
+#define ERR_INVALID_ID 205
+#define ERR_PARSE_PATH 206
+#define ERR_MAX_NODE_RESULTS 207
+#define ERR_MAX_RESULT_NODES 208
+#define ERR_MAX_COMMAND_COUNT 209
+#define ERR_MAX_ADD_COUNT 210
+#define ERR_MAX_EVAL_COUNT 211
+#define ERR_CONNECT_REDIS 301
+#define ERR_REDIS_ERROR 302
+#define ERR_NO_ACTION_AVAILABLE 303
+#define ERR_NO_TIMERS_AVAILABLE 304
+#define ERR_NEW_SESSION 305 
+#define ERR_STATE_CACHE_FULL 401
+#define ERR_BINDING_NOT_MAPPED 402
+#define ERR_STATE_NOT_LOADED 403
+#define ERR_STALE_STATE 404
+#define ERR_PROPERTY_NOT_FOUND 405
+
+#define NEXT_BUCKET_LENGTH 512
+#define NEXT_LIST_LENGTH 32
+#define BETA_LIST_LENGTH 16
+#define HASH_MASK 0x1F
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+unsigned int createRuleset(void **handle, 
+                           char *name, 
+                           char *rules, 
+                           unsigned int stateCaheSize);
+
+unsigned int deleteRuleset(void *handle);
+
+unsigned int bindRuleset(void *handle, 
+                         char *host, 
+                         unsigned int port, 
+                         char *password);
+
+unsigned int complete(void *rulesBinding, 
+                      unsigned int replyCount);
+
+unsigned int assertEvent(void *handle, 
+                         char *message);
+
+unsigned int startAssertEvent(void *handle, 
+                             char *message, 
+                             void **rulesBinding, 
+                             unsigned int *replyCount);
+
+unsigned int assertEvents(void *handle, 
+                          char *messages, 
+                          unsigned int *resultsLength, 
+                          unsigned int **results);
+
+unsigned int startAssertEvents(void *handle, 
+                              char *messages, 
+                              unsigned int *resultsLength, 
+                              unsigned int **results, 
+                              void **rulesBinding, 
+                              unsigned int *replyCount);
+
+unsigned int retractEvent(void *handle, 
+                          char *message);
+
+unsigned int startAssertFact(void *handle, 
+                             char *message, 
+                             void **rulesBinding, 
+                             unsigned int *replyCount);
+
+unsigned int assertFact(void *handle, 
+                        char *message);
+
+unsigned int startAssertFacts(void *handle, 
+                              char *messages, 
+                              unsigned int *resultsLength, 
+                              unsigned int **results, 
+                              void **rulesBinding, 
+                              unsigned int *replyCount);
+
+unsigned int assertFacts(void *handle, 
+                         char *messages, 
+                         unsigned int *resultsLength, 
+                         unsigned int **results);
+
+unsigned int retractFact(void *handle, 
+                         char *message);
+
+unsigned int startRetractFact(void *handle, 
+                             char *message, 
+                             void **rulesBinding, 
+                             unsigned int *replyCount);
+
+unsigned int retractFacts(void *handle, 
+                          char *messages, 
+                          unsigned int *resultsLength, 
+                          unsigned int **results);
+
+unsigned int startRetractFacts(void *handle, 
+                              char *messages, 
+                              unsigned int *resultsLength, 
+                              unsigned int **results, 
+                              void **rulesBinding, 
+                              unsigned int *replyCount);
+
+unsigned int startUpdateState(void *handle, 
+                              void *actionHandle, 
+                              char *state,
+                              void **rulesBinding,
+                              unsigned int *replyCount);
+
+unsigned int assertState(void *handle, 
+                         char *state);
+
+unsigned int startAction(void *handle, 
+                         char **state, 
+                         char **messages, 
+                         void **actionHandle,
+                         void **actionBinding);
+
+unsigned int completeAction(void *handle, 
+                            void *actionHandle, 
+                            char *state);
+
+unsigned int completeAndStartAction(void *handle, 
+                                    unsigned int expectedReplies,
+                                    void *actionHandle, 
+                                    char **messages);
+
+unsigned int abandonAction(void *handle, 
+                           void *actionHandle);
+
+unsigned int startTimer(void *handle, 
+                        char *sid, 
+                        unsigned int duration, 
+                        char *timer);
+
+unsigned int assertTimers(void *handle);
+
+unsigned int getState(void *handle, 
+                      char *sid, 
+                      char **state);
+
+#ifdef _WIN32
+int asprintf(char** ret, char* format, ...);
+#endif
+
+#ifdef __cplusplus
+}
+#endif

data/src/rules/state.c

@@ -0,0 +1,412 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "rules.h"
+#include "json.h"
+#include "net.h"
+
+unsigned int djbHash(char *str, unsigned int len) {
+   unsigned int hash = 5381;
+   unsigned int i = 0;
+
+   for(i = 0; i < len; str++, i++) {
+      hash = ((hash << 5) + hash) + (*str);
+   }
+
+   return hash;
+}
+
+static unsigned int evictEntry(ruleset *tree) {
+    stateEntry *lruEntry = &tree->state[tree->lruStateOffset];
+    unsigned int lruBucket = lruEntry->sidHash % tree->stateBucketsLength;
+    unsigned int offset = tree->stateBuckets[lruBucket];
+    unsigned int lastOffset = UNDEFINED_HASH_OFFSET;
+    unsigned char found = 0;
+    while (!found) {
+        stateEntry *current = &tree->state[offset];
+        if (current->sidHash == lruEntry->sidHash) {
+            if (!strcmp(current->sid, lruEntry->sid)) {
+                if (lastOffset == UNDEFINED_HASH_OFFSET) {
+                    tree->stateBuckets[lruBucket] = current->nextHashOffset;
+                } else {
+                    tree->state[lastOffset].nextHashOffset = current->nextHashOffset;
+                }
+
+                if (current->state) {
+                    free(current->state);
+                    current->state = NULL;
+                }
+
+                free(current->sid);
+                current->sid = NULL;
+                found = 1;
+            }
+        }
+
+        lastOffset = offset;
+        offset = current->nextHashOffset;
+    }
+
+    unsigned int result = tree->lruStateOffset;
+    tree->lruStateOffset = lruEntry->nextLruOffset;
+    tree->state[tree->lruStateOffset].prevLruOffset = UNDEFINED_HASH_OFFSET;
+    return result;
+}
+
+static unsigned int addEntry(ruleset *tree, char *sid, unsigned int sidHash) {
+    unsigned newOffset;
+    if (tree->stateLength == tree->maxStateLength) {
+        newOffset = evictEntry(tree);
+    } else {
+        newOffset = tree->stateLength;
+        ++tree->stateLength;
+    }
+
+    stateEntry *current = &tree->state[newOffset];
+    current->prevLruOffset = UNDEFINED_HASH_OFFSET;
+    current->nextLruOffset = UNDEFINED_HASH_OFFSET;
+    current->nextHashOffset = UNDEFINED_HASH_OFFSET;
+    current->sid = malloc(strlen(sid) + 1);
+    strcpy(current->sid, sid);
+    current->sidHash = sidHash;
+    unsigned int bucket = sidHash % tree->stateBucketsLength;
+    unsigned int offset = tree->stateBuckets[bucket];
+    if (offset == UNDEFINED_HASH_OFFSET) {
+        tree->stateBuckets[bucket] = newOffset;
+    }
+    else {
+        while (1) {
+            current = &tree->state[offset];
+            if (current->nextHashOffset == UNDEFINED_HASH_OFFSET) {
+                current->nextHashOffset = newOffset;
+                break;
+            }
+
+            offset = current->nextHashOffset;
+        }
+    }
+
+    return newOffset;
+}
+
+static unsigned char ensureEntry(ruleset *tree, char *sid, unsigned int sidHash, stateEntry **result) {
+    unsigned int bucket = sidHash % tree->stateBucketsLength;
+    unsigned int offset = tree->stateBuckets[bucket];
+    stateEntry *current = NULL;
+    unsigned char found = 0;
+    while (offset != UNDEFINED_HASH_OFFSET) {
+        current = &tree->state[offset];
+        if (current->sidHash == sidHash) {
+            if (!strcmp(current->sid, sid)) {
+                found = 1;
+                break;
+            }
+        }
+
+        offset = current->nextHashOffset;
+    }  
+    if (offset == UNDEFINED_HASH_OFFSET) {
+        offset = addEntry(tree, sid, sidHash);
+        current = &tree->state[offset];
+    }
+
+    if (current->prevLruOffset != UNDEFINED_HASH_OFFSET) {
+        tree->state[current->prevLruOffset].nextLruOffset = current->nextLruOffset;
+    }
+
+    if (current->nextLruOffset != UNDEFINED_HASH_OFFSET) {
+        tree->state[current->nextLruOffset].prevLruOffset = current->prevLruOffset;
+    }
+
+    current->prevLruOffset = tree->mruStateOffset;
+    current->nextLruOffset = UNDEFINED_HASH_OFFSET;
+    if (tree->mruStateOffset == UNDEFINED_HASH_OFFSET) {
+        tree->lruStateOffset = offset;
+    } else {
+        tree->state[tree->mruStateOffset].nextLruOffset = offset;
+    }
+
+    tree->mruStateOffset = offset;
+    *result = current;
+    return found;
+}
+
+static stateEntry *getEntry(ruleset *tree, char *sid, unsigned int sidHash) {
+    unsigned int bucket = sidHash % tree->stateBucketsLength;
+    unsigned int offset = tree->stateBuckets[bucket];
+    while (offset != UNDEFINED_HASH_OFFSET) {
+        stateEntry *current = &tree->state[offset];
+        if (current->sidHash == sidHash) {
+            if (!strcmp(current->sid, sid)) {
+                return current;
+            }
+        }
+
+        offset = current->nextHashOffset;
+    }  
+    
+    return NULL;
+}
+
+unsigned int constructObject(char *parentName, 
+                             char *object,
+                             char createHashtable,
+                             unsigned int maxProperties,
+                             jsonProperty *properties, 
+                             unsigned int *propertiesLength, 
+                             unsigned int *midIndex, 
+                             unsigned int *sidIndex,
+                             char **next) {
+    char *firstName;
+    char *lastName;
+    char *first;
+    char *last;
+    unsigned char type;
+    unsigned int hash;
+    int parentNameLength = (parentName ? strlen(parentName): 0);
+    unsigned int result = readNextName(object, &firstName, &lastName, &hash);
+    while (result == PARSE_OK) {
+        result = readNextValue(lastName, &first, &last, &type);
+        if (result != PARSE_OK) {
+            return result;
+        }
+        
+        if (!parentName) {
+            if (type == JSON_OBJECT) {
+                int nameLength = lastName - firstName;
+#ifdef _WIN32
+				char *newParent = (char *)_alloca(sizeof(char)*(nameLength + 1));
+#else
+				char newParent[nameLength + 1];
+#endif
+                strncpy(newParent, firstName, nameLength);
+                newParent[nameLength] = '\0';
+                return constructObject(newParent, 
+                                       first, 
+                                       createHashtable, 
+                                       maxProperties, 
+                                       properties, 
+                                       propertiesLength, 
+                                       midIndex, 
+                                       sidIndex, 
+                                       next);
+            }
+        } else {
+            int nameLength = lastName - firstName;
+            int fullNameLength = nameLength + parentNameLength + 1;
+#ifdef _WIN32
+			char *fullName = (char *)_alloca(sizeof(char)*(fullNameLength + 1));
+#else
+			char fullName[fullNameLength + 1];
+#endif
+            strncpy(fullName, firstName, nameLength);
+            fullName[nameLength] = '.';
+            strncpy(&fullName[nameLength + 1], parentName, parentNameLength);
+            fullName[fullNameLength] = '\0';
+            hash = djbHash(fullName, fullNameLength);
+            if (type == JSON_OBJECT) {
+                return constructObject(fullName, 
+                                       first, 
+                                       createHashtable, 
+                                       maxProperties, 
+                                       properties, 
+                                       propertiesLength, 
+                                       midIndex, 
+                                       sidIndex, 
+                                       next);
+            }
+        }
+
+        jsonProperty *property = NULL;
+        if (!createHashtable) {
+            property = &properties[*propertiesLength];
+            if (hash == HASH_ID) {
+                *midIndex = *propertiesLength;
+            } else if (hash == HASH_SID) {
+                *sidIndex = *propertiesLength;
+            }
+        } else {
+            unsigned int candidate = hash % maxProperties;
+            while (properties[candidate].type != 0) {
+                candidate = (candidate + 1) % maxProperties;
+            }
+
+            if (hash == HASH_ID) {
+                *midIndex = candidate;
+            } else if (hash == HASH_SID) {
+                *sidIndex = candidate;
+            }
+
+            property = &properties[candidate];
+        } 
+
+        
+
+        *propertiesLength = *propertiesLength + 1;
+        if (*propertiesLength == maxProperties) {
+            return ERR_EVENT_MAX_PROPERTIES;
+        }
+        
+        property->isMaterial = 0;
+        property->hash = hash;
+        property->valueOffset = first - object;
+        property->valueLength = last - first;
+        property->nameOffset = firstName - object;
+        property->nameLength = lastName - firstName;
+        property->type = type;
+        *next = last;
+        result = readNextName(last, &firstName, &lastName, &hash);
+    }
+ 
+    return (result == PARSE_END ? RULES_OK: result);
+}
+
+void rehydrateProperty(jsonProperty *property, char *state) {
+    // ID and SID are treated as strings regardless of type
+    // to avoid unnecessary conversions
+    if (!property->isMaterial && property->hash != HASH_ID && property->hash != HASH_SID) {
+        unsigned short propertyLength = property->valueLength + 1;
+        char *propertyFirst = state + property->valueOffset;
+        unsigned char propertyType = property->type;
+        unsigned char b = 0;
+        char temp;
+
+        switch(propertyType) {
+            case JSON_INT:
+                temp = propertyFirst[propertyLength];
+                propertyFirst[propertyLength] = '\0';
+                property->value.i = atol(propertyFirst);
+                propertyFirst[propertyLength] = temp;
+                break;
+            case JSON_DOUBLE:
+                temp = propertyFirst[propertyLength];
+                propertyFirst[propertyLength] = '\0';
+                property->value.d = atof(propertyFirst);
+                propertyFirst[propertyLength] = temp;
+                break;
+            case JSON_BOOL:
+                if (propertyLength == 4 && strncmp("true", propertyFirst, 4) == 0) {
+                    b = 1;
+                }
+
+                property->value.b = b;
+                break;
+        }
+
+        property->isMaterial = 1;
+    }
+}
+
+static unsigned int resolveBindingAndEntry(ruleset *tree, 
+                                          char *sid, 
+                                          stateEntry **entry,
+                                          void **rulesBinding) {   
+    unsigned int sidHash = djbHash(sid, strlen(sid));
+    if (!ensureEntry(tree, sid, sidHash, entry)) {
+        unsigned int result = getBindingIndex(tree, sidHash, &(*entry)->bindingIndex);
+        if (result != RULES_OK) {
+            return result;
+        }
+    }
+    
+    bindingsList *list = tree->bindingsList;
+    *rulesBinding = &list->bindings[(*entry)->bindingIndex];
+    return RULES_OK;
+}
+
+unsigned int resolveBinding(void *handle, 
+                            char *sid, 
+                            void **rulesBinding) {   
+    stateEntry *entry = NULL;
+    return resolveBindingAndEntry(handle, sid, &entry, rulesBinding);
+}
+
+unsigned int refreshState(void *handle, 
+                          char *sid) {
+    unsigned int result;
+    stateEntry *entry = NULL;  
+    void *rulesBinding;
+    result = resolveBindingAndEntry(handle, sid, &entry, &rulesBinding);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    if (entry->state) {
+        free(entry->state);
+        entry->state = NULL;
+    }
+
+    result = getSession(rulesBinding, sid, &entry->state);
+    if (result != RULES_OK) {
+        if (result == ERR_NEW_SESSION) {
+            entry->lastRefresh = time(NULL);    
+        }
+        return result;
+    }
+
+    memset(entry->properties, 0, MAX_STATE_PROPERTIES * sizeof(jsonProperty));
+    entry->propertiesLength = 0;
+    char *next;
+    unsigned int midIndex = UNDEFINED_INDEX;
+    unsigned int sidIndex = UNDEFINED_INDEX;
+    result =  constructObject(NULL, 
+                             entry->state, 
+                             1, 
+                             MAX_STATE_PROPERTIES, 
+                             entry->properties, 
+                             &entry->propertiesLength, 
+                             &midIndex, 
+                             &sidIndex, 
+                             &next);
+    if (result != RULES_OK) {
+        return result;
+    }
+
+    entry->lastRefresh = time(NULL);
+    return RULES_OK;
+}
+
+unsigned int fetchStateProperty(void *tree,
+                                char *sid, 
+                                unsigned int propertyHash, 
+                                unsigned int maxTime, 
+                                unsigned char ignoreStaleState,
+                                char **state,
+                                jsonProperty **property) {
+    unsigned int sidHash = djbHash(sid, strlen(sid));
+    stateEntry *entry = getEntry(tree, sid, sidHash);
+    if (entry == NULL || entry->lastRefresh == 0) {
+        return ERR_STATE_NOT_LOADED;
+    }
+    
+    if (!ignoreStaleState && (time(NULL) - entry->lastRefresh > maxTime)) {
+        return ERR_STALE_STATE;
+    }
+
+    unsigned int propertyIndex = propertyHash % MAX_STATE_PROPERTIES;
+    jsonProperty *result = &entry->properties[propertyIndex];
+    while (result->type != 0 && result->hash != propertyHash) {
+        propertyIndex = (propertyIndex + 1) % MAX_STATE_PROPERTIES;  
+        result = &entry->properties[propertyIndex];   
+    }
+
+    if (!result->type) {
+        return ERR_PROPERTY_NOT_FOUND;
+    }
+
+    *state = entry->state;
+    rehydrateProperty(result, *state);
+    *property = result;
+    return RULES_OK;    
+}
+
+unsigned int getState(void *handle, char *sid, char **state) {
+    void *rulesBinding = NULL;
+    unsigned int result = resolveBinding(handle, sid, &rulesBinding);
+    if (result != RULES_OK) {
+      return result;
+    }
+
+    return getSession(rulesBinding, sid, state);
+}