hiredis 0.1.0

data/COPYING

@@ -0,0 +1,10 @@
+Copyright (c) 2010, Pieter Noordhuis
+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.

data/Rakefile

@@ -0,0 +1,77 @@
+require 'rake'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+
+gem 'rake-compiler', '~> 0.7.1'
+require "rake/extensiontask"
+
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'hiredis/version'
+
+GEM = 'hiredis'
+GEM_VERSION = Hiredis::VERSION
+AUTHORS = ['Pieter Noordhuis']
+EMAIL = "pcnoordhuis@gmail.com"
+HOMEPAGE = "http://github.com/pietern/hiredis-rb"
+SUMMARY = "Ruby extension that wraps Hiredis (blocking connection and reply parsing)"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["COPYING"]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.authors = AUTHORS
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.require_path = 'lib'
+  s.extensions = FileList["ext/**/extconf.rb"]
+
+  ext_files = Dir.glob("ext/**/*.{rb,c,h}")
+  lib_files = Dir.glob("lib/**/*.rb")
+  hiredis_files = Dir.glob("vendor/hiredis/*.{c,h}") -
+        Dir.glob("vendor/hiredis/example*") +
+        Dir.glob("vendor/hiredis/COPYING") +
+        Dir.glob("vendor/hiredis/Makefile")
+  s.files = %w(COPYING Rakefile) + ext_files + lib_files + hiredis_files
+
+  s.add_runtime_dependency "rake-compiler", "~> 0.7.1"
+  s.add_runtime_dependency "redis", "~> 2.1.0"
+end
+
+desc "create a gemspec file"
+task :gemspec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+Rake::ExtensionTask.new('hiredis_ext') do |task|
+  # Pass --with-foo-config args to extconf.rb
+  task.config_options = ARGV[1..-1]
+  task.lib_dir = File.join(*['lib', 'hiredis'])
+end
+
+namespace :hiredis do
+  task :clean do
+    # Fetch hiredis if not present
+    if !File.directory?("vendor/hiredis/.git")
+      system("git submodule update --init")
+    end
+    system("cd vendor/hiredis && make clean")
+  end
+end
+
+# "rake clean" should also clean bundled hiredis
+Rake::Task[:clean].enhance(['hiredis:clean'])
+
+# Build from scratch
+task :build => [:clean, :compile]
+
+desc "Run tests"
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = 'test/**/*_test.rb'
+end

data/ext/hiredis_ext/connection.c

@@ -0,0 +1,215 @@
+#include <sys/socket.h>
+#include <errno.h>
+#include "hiredis_ext.h"
+
+typedef struct redisParentContext {
+    redisContext *context;
+} redisParentContext;
+
+static void parent_context_try_free(redisParentContext *pc) {
+    if (pc->context) {
+        redisFree(pc->context);
+        pc->context = NULL;
+    }
+}
+
+static void parent_context_mark(redisParentContext *pc) {
+    VALUE root;
+    fflush(stdout);
+    if (pc->context && pc->context->reader) {
+        root = (VALUE)redisReplyReaderGetObject(pc->context->reader);
+        if (root != 0 && TYPE(root) == T_ARRAY) {
+            rb_gc_mark(root);
+        }
+    }
+}
+
+static void parent_context_free(redisParentContext *pc) {
+    parent_context_try_free(pc);
+    free(pc);
+}
+
+static VALUE connection_parent_context_alloc(VALUE klass) {
+    redisParentContext *pc = malloc(sizeof(*pc));
+    pc->context = NULL;
+    return Data_Wrap_Struct(klass, parent_context_mark, parent_context_free, pc);
+}
+
+static VALUE connection_connect(VALUE self, VALUE _host, VALUE _port) {
+    redisParentContext *pc;
+    redisContext *c;
+    char *host = StringValuePtr(_host);
+    int port = NUM2INT(_port);
+    int err;
+    char errstr[1024];
+
+    Data_Get_Struct(self,redisParentContext,pc);
+    parent_context_try_free(pc);
+
+    c = redisConnect(host,port);
+    if (c->err) {
+        /* Copy error and free context */
+        err = c->err;
+        snprintf(errstr,sizeof(errstr),"%s",c->errstr);
+        redisFree(c);
+
+        if (err == REDIS_ERR_IO) {
+            /* Raise native Ruby I/O error */
+            rb_sys_fail(0);
+        } else {
+            /* Raise something else */
+            rb_raise(rb_eRuntimeError,"%s",errstr);
+        }
+    }
+
+    redisSetReplyObjectFunctions(c,&redisExtReplyObjectFunctions);
+    pc->context = c;
+    return Qnil;
+}
+
+static VALUE connection_is_connected(VALUE self) {
+    redisParentContext *pc;
+    Data_Get_Struct(self,redisParentContext,pc);
+    if (pc->context && !pc->context->err)
+        return Qtrue;
+    else
+        return Qfalse;
+}
+
+static VALUE connection_disconnect(VALUE self) {
+    redisParentContext *pc;
+    Data_Get_Struct(self,redisParentContext,pc);
+    if (!pc->context)
+        rb_raise(rb_eRuntimeError,"%s","not connected");
+    parent_context_try_free(pc);
+    return Qnil;
+}
+
+static VALUE connection_write(VALUE self, VALUE command) {
+    redisParentContext *pc;
+    int argc;
+    char **argv = NULL;
+    size_t *alen = NULL;
+    int i;
+
+    /* Commands should be an array of commands, where each command
+     * is an array of string arguments. */
+    if (TYPE(command) != T_ARRAY)
+        rb_raise(rb_eArgError,"%s","not an array");
+
+    Data_Get_Struct(self,redisParentContext,pc);
+    if (!pc->context)
+        rb_raise(rb_eRuntimeError,"%s","not connected");
+
+    argc = (int)RARRAY_LEN(command);
+    argv = malloc(argc*sizeof(char*));
+    alen = malloc(argc*sizeof(size_t));
+    for (i = 0; i < argc; i++) {
+        VALUE arg = rb_obj_as_string(RARRAY_PTR(command)[i]);
+        argv[i] = RSTRING_PTR(arg);
+        alen[i] = RSTRING_LEN(arg);
+    }
+    redisAppendCommandArgv(pc->context,argc,(const char**)argv,alen);
+    free(argv);
+    free(alen);
+    return Qnil;
+}
+
+static int __get_reply(redisParentContext *pc, VALUE *reply) {
+    redisContext *c = pc->context;
+    int wdone = 0;
+    void *aux = NULL;
+
+    /* Try to read pending replies */
+    if (redisGetReplyFromReader(c,&aux) == REDIS_ERR)
+        return -1;
+
+    if (aux == NULL) {
+        do { /* Write until done */
+            if (redisBufferWrite(c,&wdone) == REDIS_ERR)
+                return -1;
+        } while (!wdone);
+        do { /* Read until there is a reply */
+            rb_thread_wait_fd(c->fd);
+            if (redisBufferRead(c) == REDIS_ERR)
+                return -1;
+            if (redisGetReplyFromReader(c,&aux) == REDIS_ERR)
+                return -1;
+        } while (aux == NULL);
+    }
+
+    /* Set reply object */
+    if (reply != NULL) *reply = (VALUE)aux;
+    return 0;
+}
+
+static VALUE connection_read(VALUE self) {
+    redisParentContext *pc;
+    VALUE reply;
+    int err;
+    char errstr[1024];
+
+    Data_Get_Struct(self,redisParentContext,pc);
+    if (!pc->context)
+        rb_raise(rb_eRuntimeError, "not connected");
+
+    if (__get_reply(pc,&reply) == -1) {
+        /* Copy error and free context */
+        err = pc->context->err;
+        snprintf(errstr,sizeof(errstr),"%s",pc->context->errstr);
+        parent_context_try_free(pc);
+
+        switch(err) {
+        case REDIS_ERR_IO:
+            /* Raise native Ruby I/O error */
+            rb_sys_fail(0);
+            break;
+        case REDIS_ERR_EOF:
+            /* Raise our own EOF error */
+            rb_raise(error_eof,"%s",errstr);
+            break;
+        default:
+            /* Raise something else */
+            rb_raise(rb_eRuntimeError,"%s",errstr);
+        }
+    }
+
+    if (rb_ivar_defined(reply,ivar_hiredis_error)) {
+        VALUE error = rb_ivar_get(reply,ivar_hiredis_error);
+        rb_raise(rb_eRuntimeError,"%s",RSTRING_PTR(error));
+    }
+
+    return reply;
+}
+
+static VALUE connection_set_timeout(VALUE self, VALUE usecs) {
+    redisParentContext *pc;
+    int s = NUM2INT(usecs)/1000000;
+    int us = NUM2INT(usecs)-(s*1000000);
+    struct timeval timeout = { s, us };
+
+    Data_Get_Struct(self,redisParentContext,pc);
+    if (!pc->context)
+        rb_raise(rb_eRuntimeError, "not connected");
+
+    if (setsockopt(pc->context->fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) == -1)
+        rb_sys_fail(0);
+    if (setsockopt(pc->context->fd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)) == -1)
+        rb_sys_fail(0);
+    return usecs;
+}
+
+
+VALUE klass_connection;
+VALUE error_eof;
+void InitConnection(VALUE mod) {
+    klass_connection = rb_define_class_under(mod, "Connection", rb_cObject);
+    rb_define_alloc_func(klass_connection, connection_parent_context_alloc);
+    rb_define_method(klass_connection, "connect", connection_connect, 2);
+    rb_define_method(klass_connection, "connected?", connection_is_connected, 0);
+    rb_define_method(klass_connection, "disconnect", connection_disconnect, 0);
+    rb_define_method(klass_connection, "timeout=", connection_set_timeout, 1);
+    rb_define_method(klass_connection, "write", connection_write, 1);
+    rb_define_method(klass_connection, "read", connection_read, 0);
+    error_eof = rb_define_class_under(klass_connection, "EOFError", rb_eStandardError);
+}

data/ext/hiredis_ext/extconf.rb

@@ -0,0 +1,21 @@
+require 'mkmf'
+
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+def need_header(*args)
+  abort "\n--- #{args.first} is missing\n\n" if !find_header(*args)
+end
+
+def need_library(*args)
+  abort "\n--- lib#{args.first} is missing\n\n" if !find_library(*args)
+end
+
+bundled_hiredis_dir = File.join(File.dirname(__FILE__), %w{.. .. vendor hiredis})
+dir_config('hiredis', bundled_hiredis_dir, bundled_hiredis_dir)
+
+# Compile hiredis when the bundled version can be found
+system("cd #{bundled_hiredis_dir} && make static") if File.directory?(bundled_hiredis_dir)
+
+need_header('hiredis.h')
+need_library('hiredis', 'redisReplyReaderCreate')
+create_makefile('hiredis_ext/hiredis_ext')

data/ext/hiredis_ext/hiredis_ext.c

@@ -0,0 +1,11 @@
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "hiredis_ext.h"
+
+VALUE mod_hiredis;
+void Init_hiredis_ext() {
+    mod_hiredis = rb_define_module("Hiredis");
+    InitReader(mod_hiredis);
+    InitConnection(mod_hiredis);
+}

data/ext/hiredis_ext/hiredis_ext.h

@@ -0,0 +1,38 @@
+#ifndef __HIREDIS_EXT_H
+#define __HIREDIS_EXT_H
+
+#include "hiredis.h"
+#include "ruby.h"
+
+/* Defined in hiredis_ext.c */
+extern VALUE mod_hiredis;
+
+/* Defined in reader.c */
+extern redisReplyObjectFunctions redisExtReplyObjectFunctions;
+extern VALUE klass_reader;
+extern ID ivar_hiredis_error; /* ivar used to store error reply ("-ERR message") */
+extern void InitReader(VALUE module);
+
+/* Defined in connection.c */
+extern VALUE klass_connection;
+extern VALUE error_eof;
+extern void InitConnection(VALUE module);
+
+/* Borrowed from Nokogiri */
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(a) RARRAY(a)->ptr
+#endif
+
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(a) RARRAY(a)->len
+#endif
+
+#endif

data/ext/hiredis_ext/reader.c

@@ -0,0 +1,140 @@
+#include <assert.h>
+#include "hiredis_ext.h"
+
+/* Force encoding on new strings? */
+static VALUE enc_klass;
+static ID enc_default_external = 0;
+static ID str_force_encoding = 0;
+
+/* Singleton method to test if the reply contains an error. */
+ID ivar_hiredis_error;
+
+/* Add VALUE to parent when the redisReadTask has a parent.
+ * Note that the parent should always be of type T_ARRAY. */
+static void *tryParentize(const redisReadTask *task, VALUE v) {
+    if (task && task->parent != NULL) {
+        VALUE parent = (VALUE)task->parent;
+        assert(TYPE(parent) == T_ARRAY);
+        rb_ary_store(parent,task->idx,v);
+    }
+    return (void*)v;
+}
+
+static VALUE object_contains_error(VALUE self) {
+    return Qtrue;
+}
+
+static void *createStringObject(const redisReadTask *task, char *str, size_t len) {
+    VALUE v, enc;
+    v = rb_str_new(str,len);
+
+    /* Force default external encoding if possible. */
+    if (enc_default_external) {
+        enc = rb_funcall(enc_klass,enc_default_external,0);
+        v = rb_funcall(v,str_force_encoding,1,enc);
+    }
+
+    if (task->type == REDIS_REPLY_ERROR) {
+        rb_ivar_set(v,ivar_hiredis_error,v);
+        if (task && task->parent != NULL) {
+            /* Also make the parent respond to this method. Redis currently
+             * only emits nested multi bulks of depth 2, so we don't need
+             * to cascade setting this ivar. Make sure to only set the first
+             * error reply on the parent. */
+            VALUE parent = (VALUE)task->parent;
+            if (!rb_ivar_defined(parent,ivar_hiredis_error))
+                rb_ivar_set(parent,ivar_hiredis_error,v);
+        }
+    }
+
+    return tryParentize(task,v);
+}
+
+static void *createArrayObject(const redisReadTask *task, int elements) {
+    VALUE v = rb_ary_new2(elements);
+    return tryParentize(task,v);
+}
+
+static void *createIntegerObject(const redisReadTask *task, long long value) {
+    VALUE v = LL2NUM(value);
+    return tryParentize(task,v);
+}
+
+static void *createNilObject(const redisReadTask *task) {
+    return tryParentize(task,Qnil);
+}
+
+static void freeObject(void *ptr) {
+    /* Garbage collection will clean things up. */
+}
+
+/* Declare our set of reply object functions only once. */
+redisReplyObjectFunctions redisExtReplyObjectFunctions = {
+    createStringObject,
+    createArrayObject,
+    createIntegerObject,
+    createNilObject,
+    freeObject
+};
+
+static void reader_mark(void *reader) {
+    VALUE root;
+    root = (VALUE)redisReplyReaderGetObject(reader);
+    if (root != 0 && TYPE(root) == T_ARRAY) rb_gc_mark(root);
+}
+
+static VALUE reader_allocate(VALUE klass) {
+    void *reader = redisReplyReaderCreate();
+    redisReplyReaderSetReplyObjectFunctions(reader,&redisExtReplyObjectFunctions);
+    return Data_Wrap_Struct(klass, reader_mark, redisReplyReaderFree, reader);
+}
+
+static VALUE reader_feed(VALUE klass, VALUE str) {
+    void *reader;
+    unsigned int size;
+
+    if (TYPE(str) != T_STRING)
+        rb_raise(rb_eTypeError, "not a string");
+
+    Data_Get_Struct(klass, void, reader);
+    redisReplyReaderFeed(reader,RSTRING_PTR(str),(size_t)RSTRING_LEN(str));
+    return INT2NUM(0);
+}
+
+static VALUE reader_gets(VALUE klass) {
+    void *reader;
+    VALUE reply;
+
+    Data_Get_Struct(klass, void, reader);
+    if (redisReplyReaderGetReply(reader,(void**)&reply) != REDIS_OK) {
+        char *errstr = redisReplyReaderGetError(reader);
+        rb_raise(rb_eRuntimeError,"%s",errstr);
+    }
+
+    if (rb_ivar_defined(reply,ivar_hiredis_error)) {
+        VALUE error = rb_ivar_get(reply,ivar_hiredis_error);
+        rb_raise(rb_eRuntimeError,"%s",RSTRING_PTR(error));
+    }
+
+    return reply;
+}
+
+VALUE klass_reader;
+void InitReader(VALUE mod) {
+    klass_reader = rb_define_class_under(mod, "Reader", rb_cObject);
+    rb_define_alloc_func(klass_reader, reader_allocate);
+    rb_define_method(klass_reader, "feed", reader_feed, 1);
+    rb_define_method(klass_reader, "gets", reader_gets, 0);
+    ivar_hiredis_error = rb_intern("@__hiredis_error");
+
+    /* If the Encoding class is present, #default_external should be used to
+     * determine the encoding for new strings. The "enc_default_external"
+     * ID is non-zero when encoding should be set on new strings. */
+    if (rb_const_defined(rb_cObject, rb_intern("Encoding"))) {
+        enc_klass = rb_const_get(rb_cObject, rb_intern("Encoding"));
+        enc_default_external = rb_intern("default_external");
+        str_force_encoding = rb_intern("force_encoding");
+    } else {
+        enc_default_external = 0;
+    }
+}