hiredis-futureproof 0.6.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3d912067683beb1533c0e9f3912e72e8572bf372151553f4ad12a9b86db07985
+  data.tar.gz: 1715b16a9c305cc246667a88eca2b748b00f0952e9d222d2a2c2768614e5ec03
+SHA512:
+  metadata.gz: 94b5014ba1286a8707923bb9a0a839f5d0b6cecf0d420220e4e8a36fae85bf1141034b3c304dc5f6cb97da9d16be1d4bca923f672b8f6184c97cd99762626bbc
+  data.tar.gz: 8d711caf0ee44acab3ef4736601586d38784859e33c80f513a2056362d249bbc2db607f05e66f4d68f07220756a9dd4e113a0845650b34cd29bfe7dae5494180

data/COPYING

@@ -0,0 +1,28 @@
+Copyright (c) 2010-2012, 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,53 @@
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+require "rbconfig"
+require "rake/testtask"
+require "rake/extensiontask"
+
+if RUBY_PLATFORM =~ /java|mswin|mingw/i
+
+  task :rebuild do
+    # no-op
+  end
+
+else
+
+  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', 'ext'])
+  end
+
+  namespace :hiredis do
+    task :clean do
+      # Fetch hiredis if not present
+      if !File.directory?("vendor/hiredis/.git")
+        system("git submodule update --init")
+      end
+      RbConfig::CONFIG['configure_args'] =~ /with-make-prog\=(\w+)/
+      make_program = $1 || ENV['make']
+      unless make_program then
+        make_program = (/mswin/ =~ RUBY_PLATFORM) ? 'nmake' : 'make'
+      end
+      system("cd vendor/hiredis && #{make_program} clean")
+    end
+  end
+
+  # "rake clean" should also clean bundled hiredis
+  Rake::Task[:clean].enhance(['hiredis:clean'])
+
+  # Build from scratch
+  task :rebuild => [:clean, :compile]
+
+end
+
+
+
+task :default => [:rebuild, :test]
+
+desc "Run tests"
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/ext/hiredis_ext/connection.c

@@ -0,0 +1,611 @@
+#include <sys/socket.h>
+#include <errno.h>
+#include "hiredis_ext.h"
+
+#ifdef HAVE_RUBY_FIBER_SCHEDULER_H
+#include "ruby/fiber/scheduler.h"
+#include "ruby/io.h"
+
+// TODO: I copied these from Ruby; are they supposed to be exposed as part of the C extension API?
+
+#define FMODE_PREP (1<<16)
+
+static int
+io_check_tty(rb_io_t *fptr)
+{
+    int t = isatty(fptr->fd);
+    if (t)
+        fptr->mode |= FMODE_TTY|FMODE_DUPLEX;
+    return t;
+}
+
+static VALUE
+io_alloc(VALUE klass)
+{
+    NEWOBJ_OF(io, struct RFile, klass, T_FILE);
+
+    io->fptr = 0;
+
+    return (VALUE)io;
+}
+
+static VALUE
+prep_io(int fd, int fmode, VALUE klass, const char *path)
+{
+    rb_io_t *fp;
+    VALUE io = io_alloc(klass);
+
+    MakeOpenFile(io, fp);
+    fp->self = io;
+    fp->fd = fd;
+    fp->mode = fmode;
+    if (!io_check_tty(fp)) {
+#ifdef __CYGWIN__
+	fp->mode |= FMODE_BINMODE;
+	setmode(fd, O_BINARY);
+#endif
+    }
+    if (path) fp->pathv = rb_obj_freeze(rb_str_new_cstr(path));
+    rb_update_max_fd(fd);
+
+    return io;
+}
+
+static VALUE
+io_from_fd(int fd)
+{
+    return prep_io(fd, FMODE_PREP, rb_cIO, NULL);
+}
+
+#endif
+
+typedef struct redisParentContext {
+    redisContext *context;
+    struct timeval *timeout;
+} redisParentContext;
+
+static void parent_context_try_free_context(redisParentContext *pc) {
+    if (pc->context) {
+        redisFree(pc->context);
+        pc->context = NULL;
+    }
+}
+
+static void parent_context_try_free_timeout(redisParentContext *pc) {
+    if (pc->timeout) {
+        free(pc->timeout);
+        pc->timeout = NULL;
+    }
+}
+
+static void parent_context_try_free(redisParentContext *pc) {
+    parent_context_try_free_context(pc);
+    parent_context_try_free_timeout(pc);
+}
+
+static void parent_context_mark(redisParentContext *pc) {
+    // volatile until rb_gc_mark
+    volatile VALUE root;
+    if (pc->context && pc->context->reader) {
+        root = (VALUE)redisReaderGetObject(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 void parent_context_raise(redisParentContext *pc) {
+    int err;
+    char errstr[1024];
+
+    /* 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 native Ruby EOFError */
+        rb_raise(rb_eEOFError,"%s",errstr);
+        break;
+    default:
+        /* Raise something else */
+        rb_raise(rb_eRuntimeError,"%s",errstr);
+    }
+}
+
+static VALUE connection_parent_context_alloc(VALUE klass) {
+    redisParentContext *pc = malloc(sizeof(*pc));
+    pc->context = NULL;
+    pc->timeout = NULL;
+    return Data_Wrap_Struct(klass, parent_context_mark, parent_context_free, pc);
+}
+
+
+/*
+ * The rb_fdset_t API was introduced in Ruby 1.9.1. The rb_fd_thread_select
+ * function was introduced in a later version. Therefore, there are one more
+ * versions where we cannot simply test HAVE_RB_FD_INIT and be done, we have to
+ * explicitly test for HAVE_RB_THREAD_FD_SELECT (also see extconf.rb).
+ */
+#ifdef HAVE_RB_THREAD_FD_SELECT
+typedef rb_fdset_t _fdset_t;
+#define _fd_zero(f)                       rb_fd_zero(f)
+#define _fd_set(n, f)                     rb_fd_set(n, f)
+#define _fd_clr(n, f)                     rb_fd_clr(n, f)
+#define _fd_isset(n, f)                   rb_fd_isset(n, f)
+#define _fd_copy(d, s, n)                 rb_fd_copy(d, s, n)
+#define _fd_ptr(f)                        rb_fd_ptr(f)
+#define _fd_init(f)                       rb_fd_init(f)
+#define _fd_term(f)                       rb_fd_term(f)
+#define _fd_max(f)                        rb_fd_max(f)
+#define _thread_fd_select(n, r, w, e, t)  rb_thread_fd_select(n, r, w, e, t)
+#else
+typedef fd_set _fdset_t;
+#define _fd_zero(f)                       FD_ZERO(f)
+#define _fd_set(n, f)                     FD_SET(n, f)
+#define _fd_clr(n, f)                     FD_CLR(n, f)
+#define _fd_isset(n, f)                   FD_ISSET(n, f)
+#define _fd_copy(d, s, n)                 (*(d) = *(s))
+#define _fd_ptr(f)                        (f)
+#define _fd_init(f)                       FD_ZERO(f)
+#define _fd_term(f)                       (void)(f)
+#define _fd_max(f)                        FD_SETSIZE
+#define _thread_fd_select(n, r, w, e, t)  rb_thread_select(n, r, w, e, t)
+#endif
+
+static int __wait_readable(int fd, const struct timeval *timeout, int *isset) {
+#ifdef HAVE_RUBY_FIBER_SCHEDULER_H
+    VALUE scheduler = rb_fiber_scheduler_current();
+    if (scheduler != Qnil) {
+        VALUE result = rb_fiber_scheduler_io_wait(scheduler,
+                                                  io_from_fd(fd),
+                                                  RB_UINT2NUM(RUBY_IO_READABLE),
+                                                  rb_fiber_scheduler_make_timeout((struct timeval *) timeout));
+
+        if (RTEST(result)) {
+            if (isset) {
+                *isset = 1;
+            }
+            return 0;
+        } else {
+            // timeout
+            return -1;
+        }
+    }
+#endif
+
+    struct timeval to;
+    struct timeval *toptr = NULL;
+
+    _fdset_t fds;
+
+    /* Be cautious: a call to rb_fd_init to initialize the rb_fdset_t structure
+     * must be paired with a call to rb_fd_term to free it. */
+    _fd_init(&fds);
+    _fd_set(fd, &fds);
+
+    /* rb_thread_{fd_,}select modifies the passed timeval, so we pass a copy */
+    if (timeout != NULL) {
+        memcpy(&to, timeout, sizeof(to));
+        toptr = &to;
+    }
+
+    if (_thread_fd_select(fd + 1, &fds, NULL, NULL, toptr) < 0) {
+        _fd_term(&fds);
+        return -1;
+    }
+
+    if (_fd_isset(fd, &fds) && isset) {
+        *isset = 1;
+    }
+
+    _fd_term(&fds);
+    return 0;
+}
+
+static int __wait_writable(int fd, const struct timeval *timeout, int *isset) {
+#ifdef HAVE_RUBY_FIBER_SCHEDULER_H
+    VALUE scheduler = rb_fiber_scheduler_current();
+    if (scheduler != Qnil) {
+        VALUE result = rb_fiber_scheduler_io_wait(scheduler,
+                                                  io_from_fd(fd),
+                                                  RB_UINT2NUM(RUBY_IO_WRITABLE),
+                                                  rb_fiber_scheduler_make_timeout((struct timeval *) timeout));
+        if (RTEST(result)) {
+            if (isset) {
+                *isset = 1;
+            }
+            return 0;
+        } else {
+            // timeout
+            return -1;
+        }
+    }
+#endif
+
+    struct timeval to;
+    struct timeval *toptr = NULL;
+
+    _fdset_t fds;
+
+    /* Be cautious: a call to rb_fd_init to initialize the rb_fdset_t structure
+     * must be paired with a call to rb_fd_term to free it. */
+    _fd_init(&fds);
+    _fd_set(fd, &fds);
+
+    /* rb_thread_{fd_,}select modifies the passed timeval, so we pass a copy */
+    if (timeout != NULL) {
+        memcpy(&to, timeout, sizeof(to));
+        toptr = &to;
+    }
+
+    if (_thread_fd_select(fd + 1, NULL, &fds, NULL, toptr) < 0) {
+        _fd_term(&fds);
+        return -1;
+    }
+
+    if (_fd_isset(fd, &fds) && isset) {
+        *isset = 1;
+    }
+
+    _fd_term(&fds);
+    return 0;
+}
+
+static VALUE connection_generic_connect(VALUE self, redisContext *c, VALUE arg_timeout) {
+    redisParentContext *pc;
+    struct timeval tv;
+    struct timeval *timeout = NULL;
+    int writable = 0;
+    int optval = 0;
+    socklen_t optlen = sizeof(optval);
+
+    Data_Get_Struct(self,redisParentContext,pc);
+
+    if (c->err) {
+        char buf[1024];
+        int err;
+
+        /* Copy error and free context */
+        err = c->err;
+        snprintf(buf,sizeof(buf),"%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",buf);
+        }
+    }
+
+    /* Default to context-wide timeout setting */
+    if (pc->timeout != NULL) {
+        timeout = pc->timeout;
+    }
+
+    /* Override timeout when timeout argument is available */
+    if (arg_timeout != Qnil) {
+        tv.tv_sec = NUM2INT(arg_timeout) / 1000000;
+        tv.tv_usec = NUM2INT(arg_timeout) % 1000000;
+        timeout = &tv;
+    }
+
+    /* Wait for socket to become writable */
+    if (__wait_writable(c->fd, timeout, &writable) < 0) {
+        goto sys_fail;
+    }
+
+    if (!writable) {
+        errno = ETIMEDOUT;
+        goto sys_fail;
+    }
+
+    /* Check for socket error */
+    if (getsockopt(c->fd, SOL_SOCKET, SO_ERROR, &optval, &optlen) < 0) {
+        goto sys_fail;
+    }
+
+    if (optval) {
+        errno = optval;
+        goto sys_fail;
+    }
+
+    parent_context_try_free_context(pc);
+    pc->context = c;
+    pc->context->reader->fn = &redisExtReplyObjectFunctions;
+    return Qnil;
+
+sys_fail:
+    redisFree(c);
+    rb_sys_fail(0);
+}
+
+// entrypoint for Driver#connect
+static VALUE connection_connect(int argc, VALUE *argv, VALUE self) {
+    redisContext *c;
+    VALUE arg_host = Qnil;
+    VALUE arg_port = Qnil;
+    VALUE arg_timeout = Qnil;
+
+    if (argc == 2 || argc == 3) {
+        arg_host = argv[0];
+        arg_port = argv[1];
+
+        if (argc == 3) {
+            arg_timeout = argv[2];
+
+            /* Sanity check */
+            if (NUM2INT(arg_timeout) <= 0) {
+                rb_raise(rb_eArgError, "timeout should be positive");
+            }
+        }
+    } else {
+        rb_raise(rb_eArgError, "invalid number of arguments");
+    }
+
+    c = redisConnectNonBlock(StringValuePtr(arg_host), NUM2INT(arg_port));
+    return connection_generic_connect(self,c,arg_timeout);
+}
+
+static VALUE connection_connect_unix(int argc, VALUE *argv, VALUE self) {
+    redisContext *c;
+    VALUE arg_path = Qnil;
+    VALUE arg_timeout = Qnil;
+
+    if (argc == 1 || argc == 2) {
+        arg_path = argv[0];
+
+        if (argc == 2) {
+            arg_timeout = argv[1];
+
+            /* Sanity check */
+            if (NUM2INT(arg_timeout) <= 0) {
+                rb_raise(rb_eArgError, "timeout should be positive");
+            }
+        }
+    } else {
+        rb_raise(rb_eArgError, "invalid number of arguments");
+    }
+
+    c = redisConnectUnixNonBlock(StringValuePtr(arg_path));
+    return connection_generic_connect(self,c,arg_timeout);
+}
+
+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++) {
+        /* Replace arguments in the arguments array to prevent their string
+         * equivalents to be garbage collected before this loop is done. */
+        VALUE entry = rb_obj_as_string(rb_ary_entry(command, i));
+        rb_ary_store(command, i, entry);
+        argv[i] = RSTRING_PTR(entry);
+        alen[i] = RSTRING_LEN(entry);
+    }
+    redisAppendCommandArgv(pc->context,argc,(const char**)argv,alen);
+    free(argv);
+    free(alen);
+    return Qnil;
+}
+
+static VALUE connection_flush(VALUE self) {
+    redisParentContext *pc;
+    redisContext *c;
+    int wdone = 0;
+
+    Data_Get_Struct(self,redisParentContext,pc);
+    if (!pc->context)
+        rb_raise(rb_eRuntimeError, "not connected");
+
+    c = pc->context;
+    while (!wdone) {
+        errno = 0;
+
+        if (redisBufferWrite(c, &wdone) == REDIS_ERR) {
+            /* Socket error */
+            parent_context_raise(pc);
+        }
+
+        if (errno == EAGAIN) {
+            int writable = 0;
+
+            if (__wait_writable(c->fd, pc->timeout, &writable) < 0) {
+                rb_sys_fail(0);
+            }
+
+            if (!writable) {
+                errno = EAGAIN;
+                rb_sys_fail(0);
+            }
+        }
+    }
+
+    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) {
+        /* Protocol error */
+        return -1;
+    }
+
+    if (aux == NULL) {
+        /* Write until the write buffer is drained */
+        while (!wdone) {
+            errno = 0;
+
+            if (redisBufferWrite(c, &wdone) == REDIS_ERR) {
+                /* Socket error */
+                return -1;
+            }
+
+            if (errno == EAGAIN) {
+                int writable = 0;
+
+                if (__wait_writable(c->fd, pc->timeout, &writable) < 0) {
+                    rb_sys_fail(0);
+                }
+
+                if (!writable) {
+                    errno = EAGAIN;
+                    rb_sys_fail(0);
+                }
+            }
+        }
+
+        /* Read until there is a full reply */
+        while (aux == NULL) {
+            errno = 0;
+
+            if (redisBufferRead(c) == REDIS_ERR) {
+                /* Socket error */
+                return -1;
+            }
+
+            if (errno == EAGAIN) {
+                int readable = 0;
+
+                if (__wait_readable(c->fd, pc->timeout, &readable) < 0) {
+                    rb_sys_fail(0);
+                }
+
+                if (!readable) {
+                    errno = EAGAIN;
+                    rb_sys_fail(0);
+                }
+
+                /* Retry */
+                continue;
+            }
+
+            if (redisGetReplyFromReader(c,&aux) == REDIS_ERR) {
+                /* Protocol error */
+                return -1;
+            }
+        }
+    }
+
+    /* Set reply object */
+    if (reply != NULL) {
+        *reply = (VALUE)aux;
+    }
+
+    return 0;
+}
+
+static VALUE connection_read(VALUE self) {
+    redisParentContext *pc;
+    volatile VALUE reply;
+
+    Data_Get_Struct(self,redisParentContext,pc);
+    if (!pc->context)
+        rb_raise(rb_eRuntimeError, "not connected");
+
+    if (__get_reply(pc,&reply) == -1)
+        parent_context_raise(pc);
+
+    return reply;
+}
+
+static VALUE connection_set_timeout(VALUE self, VALUE usecs) {
+    redisParentContext *pc;
+    struct timeval *ptr;
+
+    Data_Get_Struct(self,redisParentContext,pc);
+
+    if (NUM2INT(usecs) < 0) {
+        rb_raise(rb_eArgError, "timeout cannot be negative");
+    } else {
+        parent_context_try_free_timeout(pc);
+
+        /* A timeout equal to zero means not to time out. This translates to a
+         * NULL timeout for select(2). Only allocate and populate the timeout
+         * when it is a positive integer. */
+        if (NUM2INT(usecs) > 0) {
+            ptr = malloc(sizeof(*ptr));
+            ptr->tv_sec = NUM2INT(usecs) / 1000000;
+            ptr->tv_usec = NUM2INT(usecs) % 1000000;
+            pc->timeout = ptr;
+        }
+    }
+
+    return Qnil;
+}
+
+static VALUE connection_fileno(VALUE self) {
+    redisParentContext *pc;
+
+    Data_Get_Struct(self,redisParentContext,pc);
+
+    if (!pc->context)
+        rb_raise(rb_eRuntimeError, "not connected");
+
+    return INT2NUM(pc->context->fd);
+}
+
+VALUE klass_connection;
+void InitConnection(VALUE mod) {
+    klass_connection = rb_define_class_under(mod, "Connection", rb_cObject);
+    rb_global_variable(&klass_connection);
+    rb_define_alloc_func(klass_connection, connection_parent_context_alloc);
+    rb_define_method(klass_connection, "connect", connection_connect, -1);
+    rb_define_method(klass_connection, "connect_unix", connection_connect_unix, -1);
+    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, "fileno", connection_fileno, 0);
+    rb_define_method(klass_connection, "write", connection_write, 1);
+    rb_define_method(klass_connection, "flush", connection_flush, 0);
+    rb_define_method(klass_connection, "read", connection_read, 0);
+}