hirlite 0.0.2.2 → 0.1.0

data/vendor/rlite/src/rlite.h

@@ -2,18 +2,18 @@
 #define _RLITE_H
 
 #include <stdio.h>
-#include "status.h"
-#include "page_btree.h"
-#include "page_key.h"
-#include "type_hash.h"
-#include "type_zset.h"
-#include "type_set.h"
-#include "type_list.h"
-#include "type_string.h"
-#include "sort.h"
-#include "restore.h"
-#include "dump.h"
-#include "util.h"
+#include "rlite/status.h"
+#include "rlite/page_btree.h"
+#include "rlite/page_key.h"
+#include "rlite/type_hash.h"
+#include "rlite/type_zset.h"
+#include "rlite/type_set.h"
+#include "rlite/type_list.h"
+#include "rlite/type_string.h"
+#include "rlite/sort.h"
+#include "rlite/restore.h"
+#include "rlite/dump.h"
+#include "rlite/util.h"
 
 #define REDIS_RDB_VERSION 6
 
@@ -50,6 +50,24 @@
 #define RLITE_OPEN_READWRITE 0x00000002
 #define RLITE_OPEN_CREATE    0x00000004
 
+#define RLITE_FLOCK_SH 1
+#define RLITE_FLOCK_EX 2
+#define RLITE_FLOCK_UN 3
+
+#define RLITE_INTERNAL_DB_COUNT 6
+#define RLITE_INTERNAL_DB_NO 0
+#define RLITE_INTERNAL_DB_LUA 1
+// the following two databases might look confusing, bear with me
+// subscriber->channels map a subscriber_id to a set of channels it is subscribed
+// channel->subscribers maps a channel to the subscribers id
+// any operation on one of them should keep the other one in sync
+// same premise applies to patterns instead of channels
+#define RLITE_INTERNAL_DB_SUBSCRIBER_CHANNELS 2
+#define RLITE_INTERNAL_DB_CHANNEL_SUBSCRIBERS 3
+#define RLITE_INTERNAL_DB_SUBSCRIBER_PATTERNS 4
+#define RLITE_INTERNAL_DB_PATTERN_SUBSCRIBERS 5
+#define RLITE_INTERNAL_DB_SUBSCRIBER_MESSAGES 6
+
 struct rlite;
 struct rl_btree;
 
@@ -93,6 +111,7 @@ typedef struct rlite {
 	long page_size;
 	void *driver;
 	int driver_type;
+	int selected_internal;
 	int selected_database;
 	int number_of_databases;
 	long *databases;
@@ -102,6 +121,10 @@ typedef struct rlite {
 	long write_pages_alloc;
 	long write_pages_len;
 	rl_page **write_pages;
+
+	char *subscriber_id;
+	char *subscriber_lock_filename;
+	FILE *subscriber_lock_fp;
 } rlite;
 
 typedef struct watched_key {
@@ -111,9 +134,12 @@ typedef struct watched_key {
 } watched_key;
 
 int rl_open(const char *filename, rlite **db, int flags);
+int rl_refresh(rlite *db);
 int rl_close(rlite *db);
 
+int rl_ensure_pages(rlite *db);
 int rl_read_header(rlite *db);
+int rl_header_deserialize(struct rlite *db, void **obj, void *context, unsigned char *data);
 int rl_read(struct rlite *db, rl_data_type *type, long page, void *context, void **obj, int cache);
 int rl_get_key_btree(rlite *db, struct rl_btree **btree, int create);
 int rl_alloc_page_number(rlite *db, long *page_number);
@@ -124,7 +150,9 @@ int rl_dirty_hash(struct rlite *db, unsigned char **hash);
 int rl_commit(struct rlite *db);
 int rl_discard(struct rlite *db);
 int rl_is_balanced(struct rlite *db);
+int rl_get_selected_db(struct rlite *db);
 int rl_select(struct rlite *db, int selected_database);
+int rl_select_internal(struct rlite *db, int internal);
 int rl_move(struct rlite *db, unsigned char *key, long keylen, int database);
 int rl_rename(struct rlite *db, const unsigned char *src, long srclen, const unsigned char *target, long targetlen, int overwrite);
 int rl_dbsize(struct rlite *db, long *size);

data/vendor/rlite/src/rlite/flock.h

@@ -0,0 +1,8 @@
+#ifndef _RL_FLOCK_H
+#define _RL_FLOCK_H
+#include <stdio.h>
+
+int rl_flock(FILE *fp, int type);
+int rl_is_flocked(const char *path, int type);
+
+#endif

data/vendor/rlite/src/{hirlite.h → rlite/hirlite.h}

@@ -107,6 +107,7 @@ struct rliteClient;
 typedef struct rliteContext {
 	int err; /* Error flags, 0 when there is no error */
 	char errstr[128]; /* String representation of error when applicable */
+	char *path;
 	rliteReply **replies;
 	int replyPosition; // avoid reallocing the pointer after removing an element, keep a reference of the next position
 	int replyLength;

data/vendor/rlite/src/rlite/pubsub.h

@@ -0,0 +1,25 @@
+#ifndef _RL_PUBSUB_H
+#define _RL_PUBSUB_H
+
+#include <sys/time.h>
+#include "rlite.h"
+
+int rl_subscribe(rlite *db, int channelc, unsigned char **channelv, long *channelvlen);
+int rl_psubscribe(rlite *db, int patternc, unsigned char **patternv, long *patternvlen);
+int rl_unsubscribe(rlite *db, int channelc, unsigned char **channelv, long *channelvlen);
+int rl_punsubscribe(rlite *db, int patternc, unsigned char **patternv, long *patternvlen);
+int rl_unsubscribe_all(rlite *db);
+int rl_poll(rlite *db, int *elementc, unsigned char ***_elements, long **_elementslen);
+/**
+ * When timeout is NULL, it will wait for ever.
+ */
+int rl_poll_wait(rlite *db, int *elementc, unsigned char ***_elements, long **_elementslen, struct timeval *timeout);
+int rl_publish(rlite *db, unsigned char *channel, size_t channellen, const char *data, size_t datalen, long *recipients);
+
+int rl_pubsub_count_subscriptions(rlite *db, long *numsubscriptions);
+int rl_pubsub_channels(rlite *db, unsigned char *pattern, long patternlen, long* channelc, unsigned char ***channelv, long **channelvlen);
+int rl_pubsub_patterns(rlite *db, long* patternc, unsigned char ***patternv, long **patternvlen);
+int rl_pubsub_numsub(rlite *db, int channelc, unsigned char **channelv, long *channelvlen, long *numsub);
+int rl_pubsub_numpat(rlite *db, long *numpat);
+
+#endif

data/vendor/rlite/src/rlite/signal.h

@@ -0,0 +1,11 @@
+#ifndef _RL_FIFO_H
+#define _RL_FIFO_H
+
+#include <sys/time.h>
+
+int rl_create_signal(const char *signal_name);
+int rl_delete_signal(const char *signal_name);
+int rl_read_signal(const char *signal_name, struct timeval *timeout, char **_data, size_t *_datalen);
+int rl_write_signal(const char *signal_name, const char *data, size_t datalen);
+
+#endif

data/vendor/rlite/src/{status.h → rlite/status.h}

@@ -15,5 +15,6 @@
 #define RL_NAN 11
 #define RL_OVERFLOW 12
 #define RL_OUTDATED 13
+#define RL_TIMEOUT 14
 
 #endif

data/vendor/rlite/src/{util.h → rlite/util.h}

@@ -59,13 +59,14 @@ int sha1_cmp(void *v1, void *v2);
 int double_cmp(void *v1, void *v2);
 #ifdef RL_DEBUG
 int long_formatter(void *v2, char **formatted, int *size);
-int sha1_formatter(void *v2, char **formatted, int *size);
 int double_formatter(void *v2, char **formatted, int *size);
 #endif
+int sha1_formatter(void *v2, char **formatted, int *size);
 double get_double(const unsigned char *p);
 void put_double(unsigned char *p, double v);
 int sha1(const unsigned char *data, long datalen, unsigned char digest[20]);
 unsigned long long rl_mstime();
 double rl_strtod(unsigned char *str, long strlen, unsigned char **eptr);
+char *rl_get_filename_with_suffix(const char *filename, char *suffix);
 
 #endif

data/vendor/rlite/src/rlite/wal.h

@@ -0,0 +1,8 @@
+#ifndef _RL_WAL_H
+#define _RL_WAL_H
+
+int rl_write_apply_wal(rlite *db);
+int rl_write_wal(const char *wal_path, rlite *db, unsigned char **_data, size_t *_datalen);
+int rl_apply_wal(rlite *db);
+
+#endif

data/vendor/rlite/src/scripting.c

@@ -29,10 +29,10 @@
  */
 
 #include "rlite.h"
-#include "hirlite.h"
-#include "sha1.h"
-#include "rand.h"
-#include "constants.h"
+#include "rlite/hirlite.h"
+#include "rlite/sha1.h"
+#include "rlite/rand.h"
+#include "rlite/constants.h"
 
 #include <lua.h>
 #include <lauxlib.h>
@@ -52,25 +52,23 @@ static int setScript(rliteClient *c, char *script, long scriptlen) {
 	int retval;
 	char hash[40];
 	sha1hex(hash, script, scriptlen);
-	int selected_database = c->context->db->selected_database;
-	c->context->db->selected_database = c->context->db->number_of_databases;
+	RL_CALL(rl_select_internal, RL_OK, c->context->db, RLITE_INTERNAL_DB_LUA);
 
 	RL_CALL(rl_set, RL_OK, c->context->db, (unsigned char *)hash, 40, (unsigned char *)script, scriptlen, 0, 0);
 
 cleanup:
-	c->context->db->selected_database = selected_database;
+	rl_select_internal(c->context->db, RLITE_INTERNAL_DB_NO);
 	return retval;
 }
 
 static int getScript(rliteClient *c, char hash[40], char **script, long *scriptlen) {
 	int retval;
-	int selected_database = c->context->db->selected_database;
-	c->context->db->selected_database = c->context->db->number_of_databases;
+	RL_CALL(rl_select_internal, RL_OK, c->context->db, RLITE_INTERNAL_DB_LUA);
 
 	RL_CALL(rl_get, RL_OK, c->context->db, (unsigned char *)hash, 40, (unsigned char **)script, scriptlen);
 
 cleanup:
-	c->context->db->selected_database = selected_database;
+	rl_select_internal(c->context->db, RLITE_INTERNAL_DB_NO);
 	return retval;
 }
 

data/vendor/rlite/src/sha1.c

@@ -25,9 +25,9 @@ A million repetitions of "a"
 #include <string.h>
 #include <sys/types.h>	/* for u_int*_t */
 #if defined(__sun)
-#include "solarisfixes.h"
+#include "rlite/solarisfixes.h"
 #endif
-#include "sha1.h"
+#include "rlite/sha1.h"
 
 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
 

data/vendor/rlite/src/signal_posix.c

@@ -0,0 +1,118 @@
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/select.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include "rlite.h"
+#include "rlite/util.h"
+#include "rlite/crc64.h"
+#include "rlite/endianconv.h"
+
+// header is 4-bytes size and 8-bytes crc
+#define FIFO_HEADER_SIZE 12
+
+int rl_create_signal(const char *signal_name) {
+	return mkfifo(signal_name, 0777) == 0 ? RL_OK : RL_UNEXPECTED;
+}
+
+int rl_delete_signal(const char *signal_name) {
+	unlink(signal_name);
+	return RL_OK;
+}
+
+int rl_read_signal(const char *signal_name, struct timeval *timeout, char **_data, size_t *_datalen)
+{
+	char header[FIFO_HEADER_SIZE];
+	uint64_t crc;
+	size_t readbytes;
+	size_t datalen;
+	int fd;
+	int retval;
+	char *data = NULL;
+	fd_set rfds;
+	int oflag = O_RDONLY;
+
+	if (timeout) {
+		// select will block, we don't want open to block
+		oflag |= O_NONBLOCK;
+	}
+
+	fd = open(signal_name, oflag);
+	if (fd == -1) {
+		retval = RL_UNEXPECTED;
+		goto cleanup;
+	}
+
+	if (timeout) {
+		FD_ZERO(&rfds);
+		FD_SET(fd, &rfds);
+		retval = select(fd + 1, &rfds, NULL, NULL, timeout);
+		if (retval == -1) {
+			retval = RL_UNEXPECTED;
+			goto cleanup;
+		} else if (retval != 0) {
+			retval = RL_TIMEOUT;
+			goto cleanup;
+		}
+	}
+
+	readbytes = read(fd, header, FIFO_HEADER_SIZE);
+	if (readbytes != FIFO_HEADER_SIZE) {
+		retval = RL_UNEXPECTED;
+		goto cleanup;
+	}
+
+	datalen = (size_t)get_4bytes((unsigned char *)header);
+	RL_MALLOC(data, sizeof(char) * datalen);
+
+	readbytes = read(fd, data, datalen);
+	if (readbytes != datalen) {
+		retval = RL_UNEXPECTED;
+		goto cleanup;
+	}
+	crc = rl_crc64(0, (unsigned char *)data, datalen);
+	memrev64ifbe(&crc);
+	memcpy(&header[4], &crc, 8);
+	if (memcmp(&crc, &header[4], 8) != 0) {
+		retval = RL_UNEXPECTED;
+		goto cleanup;
+	}
+	if (_data) {
+		*_data = data;
+	}
+	if (_datalen) {
+		*_datalen = datalen;
+	}
+	retval = RL_OK;
+cleanup:
+	if (fd >= 0) {
+		close(fd);
+	}
+	if (retval != RL_OK || _data == NULL) {
+		rl_free(data);
+	}
+	return retval;
+}
+
+int rl_write_signal(const char *signal_name, const char *data, size_t datalen) {
+	char header[FIFO_HEADER_SIZE];
+	put_4bytes((unsigned char *)header, datalen);
+
+	uint64_t crc = rl_crc64(0, (unsigned char *)data, datalen);
+	memrev64ifbe(&crc);
+	memcpy(&header[4], &crc, 8);
+
+	int fd = open(signal_name, O_WRONLY | O_NONBLOCK);
+	if (fd == -1) {
+		// fifo may not always exist on our code
+		// it is a way to signal between processes, but it is show and forget
+		return RL_OK;
+	}
+	write(fd, header, FIFO_HEADER_SIZE);
+	write(fd, data, datalen);
+	close(fd);
+	return RL_OK;
+}

data/vendor/rlite/src/signal_win.c

@@ -0,0 +1,17 @@
+#include "rlite.h"
+
+int rl_create_signal(const char *signal_name) {
+	return RL_NOT_IMPLEMENTED;
+}
+
+int rl_delete_signal(const char *signal_name) {
+	return RL_NOT_IMPLEMENTED;
+}
+
+int rl_read_signal(const char *signal_name, char **_data, size_t *_datalen) {
+	return RL_NOT_IMPLEMENTED;
+}
+
+int rl_write_signal(const char *signal_name, const char *data, size_t datalen) {
+	return RL_NOT_IMPLEMENTED;
+}

data/vendor/rlite/src/sort.c

@@ -30,8 +30,8 @@
 
 
 #include "rlite.h"
-#include "sort.h"
-#include "pqsort.h" /* Partial qsort for SORT+LIMIT */
+#include "rlite/sort.h"
+#include "rlite/pqsort.h" /* Partial qsort for SORT+LIMIT */
 #include <math.h> /* isnan() */
 #include <errno.h>