added rmutil

rmutil/Makefile

@@ -0,0 +1,17 @@
+#set environment variable RM_INCLUDE_DIR to the location of redismodule.h
+
+CFLAGS = -g -fPIC -lc -lm -O3 -std=gnu99 -I$(RM_INCLUDE_DIR)
+CC=gcc
+CFLAGS = -I$(RM_INCLUDE_DIR) 
+.SUFFIXES: .c .so .xo .o
+
+OBJS=util.o strings.o sds.o
+
+all: rmutil.a
+
+clean:
+	rm -rf *.xo *.so *.o
+
+rmutil.a: $(OBJS)
+	ar rcs $@ $^
+

rmutil/sds.h

@@ -0,0 +1,273 @@
+/* SDSLib 2.0 -- A C dynamic strings library
+ *
+ * Copyright (c) 2006-2015, Salvatore Sanfilippo <antirez at gmail dot com>
+ * Copyright (c) 2015, Oran Agra
+ * Copyright (c) 2015, Redis Labs, Inc
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __SDS_H
+#define __SDS_H
+
+#define SDS_MAX_PREALLOC (1024*1024)
+
+#include <sys/types.h>
+#include <stdarg.h>
+#include <stdint.h>
+
+typedef char *sds;
+
+/* Note: sdshdr5 is never used, we just access the flags byte directly.
+ * However is here to document the layout of type 5 SDS strings. */
+struct __attribute__ ((__packed__)) sdshdr5 {
+    unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
+    char buf[];
+};
+struct __attribute__ ((__packed__)) sdshdr8 {
+    uint8_t len; /* used */
+    uint8_t alloc; /* excluding the header and null terminator */
+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
+    char buf[];
+};
+struct __attribute__ ((__packed__)) sdshdr16 {
+    uint16_t len; /* used */
+    uint16_t alloc; /* excluding the header and null terminator */
+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
+    char buf[];
+};
+struct __attribute__ ((__packed__)) sdshdr32 {
+    uint32_t len; /* used */
+    uint32_t alloc; /* excluding the header and null terminator */
+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
+    char buf[];
+};
+struct __attribute__ ((__packed__)) sdshdr64 {
+    uint64_t len; /* used */
+    uint64_t alloc; /* excluding the header and null terminator */
+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
+    char buf[];
+};
+
+#define SDS_TYPE_5  0
+#define SDS_TYPE_8  1
+#define SDS_TYPE_16 2
+#define SDS_TYPE_32 3
+#define SDS_TYPE_64 4
+#define SDS_TYPE_MASK 7
+#define SDS_TYPE_BITS 3
+#define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T)));
+#define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))
+#define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)
+
+static inline size_t sdslen(const sds s) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            return SDS_TYPE_5_LEN(flags);
+        case SDS_TYPE_8:
+            return SDS_HDR(8,s)->len;
+        case SDS_TYPE_16:
+            return SDS_HDR(16,s)->len;
+        case SDS_TYPE_32:
+            return SDS_HDR(32,s)->len;
+        case SDS_TYPE_64:
+            return SDS_HDR(64,s)->len;
+    }
+    return 0;
+}
+
+static inline size_t sdsavail(const sds s) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5: {
+            return 0;
+        }
+        case SDS_TYPE_8: {
+            SDS_HDR_VAR(8,s);
+            return sh->alloc - sh->len;
+        }
+        case SDS_TYPE_16: {
+            SDS_HDR_VAR(16,s);
+            return sh->alloc - sh->len;
+        }
+        case SDS_TYPE_32: {
+            SDS_HDR_VAR(32,s);
+            return sh->alloc - sh->len;
+        }
+        case SDS_TYPE_64: {
+            SDS_HDR_VAR(64,s);
+            return sh->alloc - sh->len;
+        }
+    }
+    return 0;
+}
+
+static inline void sdssetlen(sds s, size_t newlen) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            {
+                unsigned char *fp = ((unsigned char*)s)-1;
+                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
+            }
+            break;
+        case SDS_TYPE_8:
+            SDS_HDR(8,s)->len = newlen;
+            break;
+        case SDS_TYPE_16:
+            SDS_HDR(16,s)->len = newlen;
+            break;
+        case SDS_TYPE_32:
+            SDS_HDR(32,s)->len = newlen;
+            break;
+        case SDS_TYPE_64:
+            SDS_HDR(64,s)->len = newlen;
+            break;
+    }
+}
+
+static inline void sdsinclen(sds s, size_t inc) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            {
+                unsigned char *fp = ((unsigned char*)s)-1;
+                unsigned char newlen = SDS_TYPE_5_LEN(flags)+inc;
+                *fp = SDS_TYPE_5 | (newlen << SDS_TYPE_BITS);
+            }
+            break;
+        case SDS_TYPE_8:
+            SDS_HDR(8,s)->len += inc;
+            break;
+        case SDS_TYPE_16:
+            SDS_HDR(16,s)->len += inc;
+            break;
+        case SDS_TYPE_32:
+            SDS_HDR(32,s)->len += inc;
+            break;
+        case SDS_TYPE_64:
+            SDS_HDR(64,s)->len += inc;
+            break;
+    }
+}
+
+/* sdsalloc() = sdsavail() + sdslen() */
+static inline size_t sdsalloc(const sds s) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            return SDS_TYPE_5_LEN(flags);
+        case SDS_TYPE_8:
+            return SDS_HDR(8,s)->alloc;
+        case SDS_TYPE_16:
+            return SDS_HDR(16,s)->alloc;
+        case SDS_TYPE_32:
+            return SDS_HDR(32,s)->alloc;
+        case SDS_TYPE_64:
+            return SDS_HDR(64,s)->alloc;
+    }
+    return 0;
+}
+
+static inline void sdssetalloc(sds s, size_t newlen) {
+    unsigned char flags = s[-1];
+    switch(flags&SDS_TYPE_MASK) {
+        case SDS_TYPE_5:
+            /* Nothing to do, this type has no total allocation info. */
+            break;
+        case SDS_TYPE_8:
+            SDS_HDR(8,s)->alloc = newlen;
+            break;
+        case SDS_TYPE_16:
+            SDS_HDR(16,s)->alloc = newlen;
+            break;
+        case SDS_TYPE_32:
+            SDS_HDR(32,s)->alloc = newlen;
+            break;
+        case SDS_TYPE_64:
+            SDS_HDR(64,s)->alloc = newlen;
+            break;
+    }
+}
+
+sds sdsnewlen(const void *init, size_t initlen);
+sds sdsnew(const char *init);
+sds sdsempty(void);
+sds sdsdup(const sds s);
+void sdsfree(sds s);
+sds sdsgrowzero(sds s, size_t len);
+sds sdscatlen(sds s, const void *t, size_t len);
+sds sdscat(sds s, const char *t);
+sds sdscatsds(sds s, const sds t);
+sds sdscpylen(sds s, const char *t, size_t len);
+sds sdscpy(sds s, const char *t);
+
+sds sdscatvprintf(sds s, const char *fmt, va_list ap);
+#ifdef __GNUC__
+sds sdscatprintf(sds s, const char *fmt, ...)
+    __attribute__((format(printf, 2, 3)));
+#else
+sds sdscatprintf(sds s, const char *fmt, ...);
+#endif
+
+sds sdscatfmt(sds s, char const *fmt, ...);
+sds sdstrim(sds s, const char *cset);
+void sdsrange(sds s, int start, int end);
+void sdsupdatelen(sds s);
+void sdsclear(sds s);
+int sdscmp(const sds s1, const sds s2);
+sds *sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count);
+void sdsfreesplitres(sds *tokens, int count);
+void sdstolower(sds s);
+void sdstoupper(sds s);
+sds sdsfromlonglong(long long value);
+sds sdscatrepr(sds s, const char *p, size_t len);
+sds *sdssplitargs(const char *line, int *argc);
+sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen);
+sds sdsjoin(char **argv, int argc, char *sep);
+sds sdsjoinsds(sds *argv, int argc, const char *sep, size_t seplen);
+
+/* Low level functions exposed to the user API */
+sds sdsMakeRoomFor(sds s, size_t addlen);
+void sdsIncrLen(sds s, int incr);
+sds sdsRemoveFreeSpace(sds s);
+size_t sdsAllocSize(sds s);
+void *sdsAllocPtr(sds s);
+
+/* Export the allocator used by SDS to the program using SDS.
+ * Sometimes the program SDS is linked to, may use a different set of
+ * allocators, but may want to allocate or free things that SDS will
+ * respectively free or allocate. */
+void *sds_malloc(size_t size);
+void *sds_realloc(void *ptr, size_t size);
+void sds_free(void *ptr);
+
+#ifdef REDIS_TEST
+int sdsTest(int argc, char *argv[]);
+#endif
+
+#endif

rmutil/strings.c

@@ -0,0 +1,53 @@
+#include <string.h>
+#include <sys/param.h>
+#include <ctype.h>
+#include "strings.h"
+
+
+#include "sds.h"
+
+RedisModuleString *RMUtils_CreateFormattedString(RedisModuleCtx *ctx, const char *fmt, ...) {
+    sds s = sdsempty();
+    
+    va_list ap;
+    va_start(ap, fmt);
+    s = sdscatvprintf(s, fmt, ap);
+    va_end(ap);
+    
+    RedisModuleString *ret = RedisModule_CreateString(ctx, (const char *)s, sdslen(s));
+    sdsfree(s);
+    return ret;
+}
+
+int RMUtils_StringEquals(RedisModuleString *s1, RedisModuleString *s2) {
+    
+    const char *c1, *c2;
+    size_t l1, l2;
+    c1 = RedisModule_StringPtrLen(s1, &l1);
+    c2 = RedisModule_StringPtrLen(s2, &l2);
+    
+    return strncasecmp(c1, c2, MIN(l1,l2)) == 0;
+}
+
+void RMUtils_StringToLower(RedisModuleString *s) {
+    
+    size_t l;
+    char *c = (char *)RedisModule_StringPtrLen(s, &l);
+    size_t i;
+    for (i = 0; i < l; i++) {
+        *c = tolower(*c);
+        ++c;
+    }
+    
+}
+
+void RMUtils_StringToUpper(RedisModuleString *s) {
+    size_t l;
+    char *c = (char *)RedisModule_StringPtrLen(s, &l);
+    size_t i;
+    for (i = 0; i < l; i++) {
+        *c = toupper(*c);
+        ++c;
+    }
+    
+}

rmutil/strings.h

@@ -0,0 +1,22 @@
+#ifndef __RMUTIL_STRINGS_H__
+#define __RMUTIL_STRINGS_H__
+
+#include <redismodule.h>
+
+/*
+* Create a new RedisModuleString object from a printf-style format and arguments.
+* Note that RedisModuleString objects CANNOT be used as formatting arguments.
+*/
+RedisModuleString *RMUtils_CreateFormattedString(RedisModuleCtx *ctx, const char *fmt, ...);
+
+/* Return 1 if the two strings are equal. Case *sensitive* */
+int RMUtils_StringEquals(RedisModuleString *s1, RedisModuleString *s2);
+
+/* Converts a redis string to lowercase in place without reallocating anything */
+void RMUtils_StringToLower(RedisModuleString *s);
+
+/* Converts a redis string to uppercase in place without reallocating anything */
+void RMUtils_StringToUpper(RedisModuleString *s);
+
+
+#endif

rmutil/util.c

@@ -0,0 +1,117 @@
+#include <stdlib.h>
+#include <errno.h>
+#include <math.h>
+#include <ctype.h>
+#include <sys/time.h>
+#include <limits.h>
+#include <string.h>
+#include "util.h"
+
+/**
+Check if an argument exists in an argument list (argv,argc), starting at offset.
+@return 0 if it doesn't exist, otherwise the offset it exists in
+*/
+int RMUtil_ArgExists(const char *arg, RedisModuleString **argv, int argc, int offset) {
+
+    for (; offset < argc; offset++) {
+        size_t l;
+        const char *carg = RedisModule_StringPtrLen(argv[offset], &l);
+        if (carg != NULL && strncasecmp(carg, arg, l) == 0) {
+            return offset;
+        }
+    }
+    return 0;
+}
+
+RMUtilInfo *RMUtil_GetRedisInfo(RedisModuleCtx *ctx) {
+    
+    RedisModuleCallReply *r = RedisModule_Call(ctx, "INFO", "c", "all");
+    if (r == NULL || RedisModule_CallReplyType(r) == REDISMODULE_REPLY_ERROR) {
+        return NULL;
+    }
+    
+    
+    int cap = 100; // rough estimate of info lines
+    RMUtilInfo *info = malloc(sizeof(RMUtilInfo));
+    info->entries = calloc(cap, sizeof(RMUtilInfoEntry));
+    
+    int i = 0;
+    char *text = (char *)RedisModule_StringPtrLen(RedisModule_CreateStringFromCallReply(r), NULL);
+    char *line = text;
+    while (line) {
+        char *line = strsep(&text, "\r\n");
+        if (line == NULL)  break;
+        
+        if (!(*line >= 'a' && *line <= 'z')) { //skip non entry lines 
+            continue;
+        }
+        
+        char *key = strsep(&line, ":");
+        info->entries[i].key = key;
+        info->entries[i].val = line;
+        printf("Got info '%s' = '%s'\n", key, line);
+        i++;
+        if (i >= cap) {
+            cap *=2;
+            info->entries = realloc(info->entries, cap*sizeof(RMUtilInfoEntry));
+        }
+    } 
+    info->numEntries = i;
+    
+    return info;
+    
+}
+void RMUtilRedisInfo_Free(RMUtilInfo *info) {
+    
+    free(info->entries);
+    free(info);
+    
+}
+
+int RMUtilInfo_GetInt(RMUtilInfo *info, const char *key, long long *val) {
+    
+     const char *p = NULL;
+     if (!RMUtilInfo_GetString(info, key, &p)) {
+         return 0;
+     }
+     
+     *val = strtoll(p, NULL, 10);
+     if ((errno == ERANGE && (*val == LONG_MAX || *val == LONG_MIN)) ||
+        (errno != 0 && *val == 0)) {
+       *val = -1;
+       return 0;
+    }
+     
+    
+    return 1;
+}
+
+
+int RMUtilInfo_GetString(RMUtilInfo *info, const char *key, const char **str) {
+    int i;
+    for (i = 0; i < info->numEntries; i++) {
+        if (!strcmp(key, info->entries[i].key)) {
+            *str = info->entries[i].val;
+            return 1;
+        }
+    }
+    return 0;
+}
+
+int RMUtilInfo_GetDouble(RMUtilInfo *info, const char *key, double *d) {
+     const char *p = NULL;
+     if (!RMUtilInfo_GetString(info, key, &p)) {
+         printf("not found %s\n", key);
+         return 0;
+     }
+     
+     *d = strtod(p, NULL);
+     printf("p: %s, d: %f\n",p,*d);
+     if ((errno == ERANGE && (*d == HUGE_VAL || *d == -HUGE_VAL)) ||
+        (errno != 0 && *d == 0)) {
+       return 0;
+    }
+     
+    
+    return 1;
+}

rmutil/util.h

@@ -0,0 +1,67 @@
+#ifndef __UTIL_H__
+#define __UTIL_H__
+
+#include <redismodule.h>
+
+// make sure the response is not NULL or an error, and if it is sends the error to the client and exit the current function
+#define  REDIS_ASSERT_NOERROR(r) \
+    if (r == NULL) { \
+        return RedisModule_ReplyWithError(ctx,"ERR reply is NULL"); \
+    } else if (RedisModule_CallReplyType(r) == REDISMODULE_REPLY_ERROR) { \
+        RedisModule_ReplyWithCallReply(ctx,r); \
+        return REDISMODULE_ERR; \
+    }
+
+
+/* RedisModule utilities. */
+
+/* Return the offset of an arg if it exists in the arg list, or 0 if it's not there */
+int RMUtil_ArgExists(const char *arg, RedisModuleString **argv, int argc, int offset);
+
+// NOT IMPLEMENTED YET
+int RMUtil_ParseArgs(RedisModuleString **argv, int argc, const char *fmt, ...);
+
+// A single key/value entry in a redis info map
+typedef struct {
+    const char *key;
+    const char *val;
+} RMUtilInfoEntry;
+
+// Representation of INFO command response, as a list of k/v pairs
+typedef struct {
+    RMUtilInfoEntry *entries;
+    int numEntries;
+} RMUtilInfo;
+
+/*
+* Get redis INFO result and parse it as RMUtilInfo.
+* Returns NULL if something goes wrong.
+* The resulting object needs to be freed with RMUtilRedisInfo_Free
+*/
+RMUtilInfo *RMUtil_GetRedisInfo(RedisModuleCtx *ctx);
+
+/*
+* Free an RMUtilInfo object and its entries
+*/
+void RMUtilRedisInfo_Free(RMUtilInfo *info);
+
+/**
+* Get an integer value from an info object. Returns 1 if the value was found and 
+* is an integer, 0 otherwise. the value is placed in 'val'
+*/
+int RMUtilInfo_GetInt(RMUtilInfo *info, const char *key, long long *val);
+
+/*
+* Get a string value from an info object. The value is placed in str.
+* Returns 1 if the key was found, 0 if not 
+*/
+int RMUtilInfo_GetString(RMUtilInfo *info, const char *key, const char **str);
+
+/*
+* Get a double value from an info object. Returns 1 if the value was found and is 
+* a correctly formatted double, 0 otherwise. the value is placed in 'd'
+*/
+int RMUtilInfo_GetDouble(RMUtilInfo *info, const char *key, double *d);
+
+
+#endif