hiredis 0.3.2 → 0.4.1

data/Rakefile

@@ -1,28 +1,42 @@
-require 'rake'
-require 'rake/testtask'
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+require "rake/testtask"
 require "rake/extensiontask"
 
-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
+unless defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+
+  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")
+  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
-    system("cd vendor/hiredis && make clean")
   end
-end
 
-# "rake clean" should also clean bundled hiredis
-Rake::Task[:clean].enhance(['hiredis:clean'])
+  # "rake clean" should also clean bundled hiredis
+  Rake::Task[:clean].enhance(['hiredis:clean'])
+
+  # Build from scratch
+  task :rebuild => [:clean, :compile]
+
+else
+
+  task :rebuild do
+    # no-op
+  end
+
+end
 
-# Build from scratch
-task :build => [:clean, :compile]
+task :default => [:rebuild, :test]
 
 desc "Run tests"
 Rake::TestTask.new(:test) do |t|

data/ext/hiredis_ext/connection.c

@@ -4,15 +4,28 @@
 
 typedef struct redisParentContext {
     redisContext *context;
+    struct timeval *timeout;
 } redisParentContext;
 
-static void parent_context_try_free(redisParentContext *pc) {
+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) {
     VALUE root;
     if (pc->context && pc->context->reader) {
@@ -43,8 +56,8 @@ static void parent_context_raise(redisParentContext *pc) {
         rb_sys_fail(0);
         break;
     case REDIS_ERR_EOF:
-        /* Raise our own EOF error */
-        rb_raise(error_eof,"%s",errstr);
+        /* Raise native Ruby EOFError */
+        rb_raise(rb_eEOFError,"%s",errstr);
         break;
     default:
         /* Raise something else */
@@ -55,20 +68,56 @@ static void parent_context_raise(redisParentContext *pc) {
 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);
 }
 
-static VALUE connection_generic_connect(VALUE self, redisContext *c) {
+static int __wait_readable(int fd, struct timeval *timeout, int *isset) {
+    fd_set fds;
+    FD_ZERO(&fds);
+    FD_SET(fd, &fds);
+
+    if (rb_thread_select(fd + 1, &fds, NULL, NULL, timeout) < 0) {
+        return -1;
+    }
+
+    if (FD_ISSET(fd, &fds) && isset) {
+        *isset = 1;
+    }
+
+    return 0;
+}
+
+static int __wait_writable(int fd, struct timeval *timeout, int *isset) {
+    fd_set fds;
+    FD_ZERO(&fds);
+    FD_SET(fd, &fds);
+
+    if (rb_thread_select(fd + 1, NULL, &fds, NULL, timeout) < 0) {
+        return -1;
+    }
+
+    if (FD_ISSET(fd, &fds) && isset) {
+        *isset = 1;
+    }
+
+    return 0;
+}
+
+static VALUE connection_generic_connect(VALUE self, redisContext *c, VALUE arg_timeout) {
     redisParentContext *pc;
-    int err;
-    char errstr[1024];
+    struct timeval tv;
+    struct timeval *timeout = NULL;
 
     Data_Get_Struct(self,redisParentContext,pc);
 
     if (c->err) {
+        char buf[1024];
+        int err;
+
         /* Copy error and free context */
         err = c->err;
-        snprintf(errstr,sizeof(errstr),"%s",c->errstr);
+        snprintf(buf,sizeof(buf),"%s",c->errstr);
         redisFree(c);
 
         if (err == REDIS_ERR_IO) {
@@ -76,86 +125,107 @@ static VALUE connection_generic_connect(VALUE self, redisContext *c) {
             rb_sys_fail(0);
         } else {
             /* Raise something else */
-            rb_raise(rb_eRuntimeError,"%s",errstr);
+            rb_raise(rb_eRuntimeError,"%s",buf);
         }
     }
 
-    c->reader->fn = &redisExtReplyObjectFunctions;
+    /* 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 */
+    int writable = 0;
+    if (__wait_writable(c->fd, timeout, &writable) < 0) {
+        goto sys_fail;
+    }
+
+    if (!writable) {
+        errno = ETIMEDOUT;
+        goto sys_fail;
+    }
+
+    /* Check for socket error */
+    int optval = 0;
+    socklen_t optlen = sizeof(optval);
+    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;
-}
 
-static struct timeval __timeout_from_robj(VALUE usecs) {
-    int s = NUM2INT(usecs)/1000000;
-    int us = NUM2INT(usecs)-(s*1000000);
-    struct timeval timeout = { s, us };
-    return timeout;
+sys_fail:
+    redisFree(c);
+    rb_sys_fail(0);
 }
 
 static VALUE connection_connect(int argc, VALUE *argv, VALUE self) {
     redisParentContext *pc;
     redisContext *c;
-    VALUE *_host = NULL;
-    VALUE *_port = NULL;
-    VALUE *_timeout = NULL;
-    char *host;
-    int port;
-    struct timeval timeout;
+    VALUE arg_host = Qnil;
+    VALUE arg_port = Qnil;
+    VALUE arg_timeout = Qnil;
 
     if (argc == 2 || argc == 3) {
-        _host = &argv[0];
-        _port = &argv[1];
-        if (argc == 3)
-            _timeout = &argv[2];
-    } else {
-        rb_raise(rb_eArgError, "invalid number of arguments");
-        return Qnil;
-    }
+        arg_host = argv[0];
+        arg_port = argv[1];
 
-    Data_Get_Struct(self,redisParentContext,pc);
-    parent_context_try_free(pc);
+        if (argc == 3) {
+            arg_timeout = argv[2];
 
-    host = StringValuePtr(*_host);
-    port = NUM2INT(*_port);
-    if (_timeout != NULL) {
-        timeout = __timeout_from_robj(*_timeout);
-        c = redisConnectWithTimeout(host,port,timeout);
+            /* Sanity check */
+            if (NUM2INT(arg_timeout) <= 0) {
+                rb_raise(rb_eArgError, "timeout should be positive");
+            }
+        }
     } else {
-        c = redisConnect(host,port);
+        rb_raise(rb_eArgError, "invalid number of arguments");
     }
 
-    return connection_generic_connect(self,c);
+    Data_Get_Struct(self,redisParentContext,pc);
+    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) {
     redisParentContext *pc;
     redisContext *c;
-    VALUE *_path = NULL;
-    VALUE *_timeout = NULL;
-    char *path;
-    struct timeval timeout;
+    VALUE arg_path = Qnil;
+    VALUE arg_timeout = Qnil;
 
     if (argc == 1 || argc == 2) {
-        _path = &argv[0];
-        if (argc == 2)
-            _timeout = &argv[1];
-    } else {
-        rb_raise(rb_eArgError, "invalid number of arguments");
-        return Qnil;
-    }
+        arg_path = argv[0];
 
-    Data_Get_Struct(self,redisParentContext,pc);
-    parent_context_try_free(pc);
+        if (argc == 2) {
+            arg_timeout = argv[1];
 
-    path = StringValuePtr(*_path);
-    if (_timeout != NULL) {
-        timeout = __timeout_from_robj(*_timeout);
-        c = redisConnectUnixWithTimeout(path,timeout);
+            /* Sanity check */
+            if (NUM2INT(arg_timeout) <= 0) {
+                rb_raise(rb_eArgError, "timeout should be positive");
+            }
+        }
     } else {
-        c = redisConnectUnix(path);
+        rb_raise(rb_eArgError, "invalid number of arguments");
     }
 
-    return connection_generic_connect(self,c);
+    Data_Get_Struct(self,redisParentContext,pc);
+    c = redisConnectUnixNonBlock(StringValuePtr(arg_path));
+    return connection_generic_connect(self,c,arg_timeout);
 }
 
 static VALUE connection_is_connected(VALUE self) {
@@ -210,31 +280,113 @@ static VALUE connection_write(VALUE self, VALUE command) {
     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)
+    if (redisGetReplyFromReader(c,&aux) == REDIS_ERR) {
+        /* Protocol error */
         return -1;
+    }
 
     if (aux == NULL) {
-        do { /* Write until done */
-            if (redisBufferWrite(c,&wdone) == REDIS_ERR)
+        /* Write until the write buffer is drained */
+        while (!wdone) {
+            errno = 0;
+
+            if (redisBufferWrite(c, &wdone) == REDIS_ERR) {
+                /* Socket error */
                 return -1;
-        } while (!wdone);
-        do { /* Read until there is a reply */
-            rb_thread_wait_fd(c->fd);
-            if (redisBufferRead(c) == REDIS_ERR)
+            }
+
+            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 (redisGetReplyFromReader(c,&aux) == REDIS_ERR)
+            }
+
+            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;
-        } while (aux == NULL);
+            }
+        }
     }
 
     /* Set reply object */
-    if (reply != NULL) *reply = (VALUE)aux;
+    if (reply != NULL) {
+        *reply = (VALUE)aux;
+    }
+
     return 0;
 }
 
@@ -254,23 +406,41 @@ static VALUE connection_read(VALUE self) {
 
 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 };
+    struct timeval *ptr;
 
     Data_Get_Struct(self,redisParentContext,pc);
-    if (!pc->context)
-        rb_raise(rb_eRuntimeError, "not connected");
 
-    if (redisSetTimeout(pc->context,timeout) == REDIS_ERR)
-        parent_context_raise(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 usecs;
+    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;
-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);
@@ -279,7 +449,8 @@ void InitConnection(VALUE mod) {
     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);
-    error_eof = rb_define_class_under(klass_connection, "EOFError", rb_eStandardError);
 }

data/lib/hiredis/ext/connection.rb

@@ -1,16 +1,29 @@
 require "hiredis/ext/hiredis_ext"
 require "hiredis/version"
+require "socket"
 
 module Hiredis
   module Ext
     class Connection
-      # Raise CONNRESET on EOF
+      alias :_disconnect :disconnect
+
+      def disconnect
+        _disconnect
+      ensure
+        @sock = nil
+      end
+
       alias :_read :read
+
       def read
         _read
-      rescue EOFError
+      rescue ::EOFError
         raise Errno::ECONNRESET
       end
+
+      def sock
+        @sock ||= Socket.for_fd(fileno)
+      end
     end
   end
 end

data/lib/hiredis/ruby/connection.rb

@@ -1,5 +1,4 @@
 require "socket"
-require "timeout"
 require "hiredis/ruby/reader"
 require "hiredis/version"
 
@@ -7,46 +6,211 @@ module Hiredis
   module Ruby
     class Connection
 
-      def initialize
-        @sock = nil
-      end
+      if defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx"
+
+        def self.errno_to_class
+          Errno::Mapping
+        end
+
+      else
+
+        def self.errno_to_class
+          @mapping ||= Hash[Errno.constants.map do |name|
+            klass = Errno.const_get(name)
+            [klass.const_get("Errno"), klass]
+          end]
+        end
 
-      def connected?
-        !! @sock
       end
 
-      def connect(host, port, usecs = 0)
-        @reader = ::Hiredis::Ruby::Reader.new
+      if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+
+        require "timeout"
+
+        def _connect(host, port, timeout)
+          sock = nil
+
+          begin
+            Timeout.timeout(timeout) do
+              sock = TCPSocket.new(host, port)
+            end
+          rescue SocketError => se
+            raise se.message
+          rescue Timeout::Error
+            raise Errno::ETIMEDOUT
+          end
+
+          sock
+        end
+
+        def _connect_unix(path, timeout)
+          sock = nil
 
-        begin
           begin
-            Timeout.timeout(usecs.to_f / 1_000_000) do
-              @sock = TCPSocket.new(host, port)
-              @sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+            Timeout.timeout(timeout) do
+              sock = UNIXSocket.new(path)
             end
+          rescue SocketError => se
+            raise se.message
           rescue Timeout::Error
             raise Errno::ETIMEDOUT
           end
-        rescue SocketError => error
-          # Raise RuntimeError when host cannot be resolved
-          if error.message.start_with?("getaddrinfo:")
-            raise error.message
-          else
-            raise error
+
+          sock
+        end
+
+        def _write(sock, data, timeout)
+          begin
+            Timeout.timeout(timeout) do
+              sock.write(data)
+            end
+          rescue Timeout::Error
+            raise Errno::EAGAIN
+          end
+        end
+
+      else
+
+        def _connect(host, port, timeout)
+          error = nil
+          sock = nil
+
+          # Resolve address
+          begin
+            addrinfo = Socket.getaddrinfo(host, port, Socket::AF_UNSPEC, Socket::SOCK_STREAM)
+          rescue SocketError => se
+            raise se.message
+          end
+
+          addrinfo.each do |_, port, name, addr, af|
+            begin
+              sockaddr = Socket.pack_sockaddr_in(port, addr)
+              sock = _connect_sockaddr(af, sockaddr, timeout)
+            rescue => aux
+              case aux
+              when Errno::EAFNOSUPPORT, Errno::ECONNREFUSED
+                error = aux
+                next
+              else
+                # Re-raise
+                raise
+              end
+            else
+              # No errors, awesome!
+              break
+            end
+          end
+
+          unless sock
+            # Re-raise last error since the last try obviously failed
+            raise error if error
+
+            # This code path should not happen: getaddrinfo should always return
+            # at least one record, which should either succeed or fail and leave
+            # and error to raise.
+            raise
+          end
+
+          sock
+        end
+
+        def _connect_unix(path, timeout)
+          sockaddr = Socket.pack_sockaddr_un(path)
+          _connect_sockaddr(Socket::AF_UNIX, sockaddr, timeout)
+        end
+
+        def _write(sock, data, timeout)
+          data.force_encoding("binary") if data.respond_to?(:force_encoding)
+
+          begin
+            nwritten = @sock.write_nonblock(data)
+
+            while nwritten < string_size(data)
+              data = data[nwritten..-1]
+              nwritten = @sock.write_nonblock(data)
+            end
+          rescue Errno::EAGAIN
+            if IO.select([], [@sock], [], timeout)
+              # Writable, try again
+              retry
+            else
+              # Timed out, raise
+              raise Errno::EAGAIN
+            end
+          end
+        end
+
+        def _connect_sockaddr(af, sockaddr, timeout)
+          sock = Socket.new(af, Socket::SOCK_STREAM, 0)
+
+          begin
+            sock.connect_nonblock(sockaddr)
+          rescue Errno::EINPROGRESS
+            if IO.select(nil, [sock], nil, timeout)
+              # Writable, check for errors
+              optval = sock.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR)
+              errno = optval.unpack("i").first
+
+              # Raise socket error if there is any
+              raise self.class.errno_to_class[errno] if errno > 0
+            else
+              # Timeout (TODO: replace with own Timeout class)
+              raise Errno::ETIMEDOUT
+            end
           end
+
+          sock
+        rescue
+          sock.close if sock
+
+          # Re-raise
+          raise
         end
+
+        private :_connect_sockaddr
+
+      end
+
+      attr_reader :sock
+
+      def initialize
+        @sock = nil
+        @timeout = nil
+      end
+
+      def connected?
+        !! @sock
+      end
+
+      def connect(host, port, usecs = nil)
+        # Temporarily override timeout on #connect
+        timeout = usecs ? (usecs / 1_000_000.0) : @timeout
+
+        # Optionally disconnect current socket
+        disconnect if connected?
+
+        sock = _connect(host, port, timeout)
+        sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+
+        @reader = ::Hiredis::Ruby::Reader.new
+        @sock = sock
+
+        nil
       end
 
       def connect_unix(path, usecs = 0)
+        # Temporarily override timeout on #connect
+        timeout = usecs ? (usecs / 1_000_000.0) : @timeout
+
+        # Optionally disconnect current socket
+        disconnect if connected?
+
+        sock = _connect_unix(path, timeout)
+
         @reader = ::Hiredis::Ruby::Reader.new
+        @sock = sock
 
-        begin
-          Timeout.timeout(usecs.to_f / 1_000_000) do
-            @sock = UNIXSocket.new(path)
-          end
-        rescue Timeout::Error
-          raise Errno::ETIMEDOUT
-        end
+        nil
       end
 
       def disconnect
@@ -57,18 +221,21 @@ module Hiredis
       end
 
       def timeout=(usecs)
-        raise "not connected" unless connected?
+        raise ArgumentError.new("timeout cannot be negative") if usecs < 0
 
-        secs   = Integer(usecs / 1_000_000)
-        usecs  = Integer(usecs - (secs * 1_000_000)) # 0 - 999_999
+        if usecs == 0
+          @timeout = nil
+        else
+          @timeout = usecs / 1_000_000.0
+        end
 
-        optval = [secs, usecs].pack("l_2")
+        nil
+      end
 
-        begin
-          @sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
-          @sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
-        rescue Errno::ENOPROTOOPT
-        end
+      def fileno
+        raise "not connected" unless connected?
+
+        @sock.fileno
       end
 
       COMMAND_DELIMITER = "\r\n".freeze
@@ -82,18 +249,36 @@ module Hiredis
           command << arg
         end
 
-        @sock.syswrite(command.join(COMMAND_DELIMITER) + COMMAND_DELIMITER)
+        data = command.join(COMMAND_DELIMITER) + COMMAND_DELIMITER
+
+        _write(@sock, data, @timeout)
+
+        nil
+      end
+
+      # No-op for now..
+      def flush
       end
 
       def read
         raise "not connected" unless connected?
 
         while (reply = @reader.gets) == false
-          @reader.feed @sock.sysread(1024)
+          begin
+            @reader.feed @sock.read_nonblock(1024)
+          rescue Errno::EAGAIN
+            if IO.select([@sock], [], [], @timeout)
+              # Readable, try again
+              retry
+            else
+              # Timed out, raise
+              raise Errno::EAGAIN
+            end
+          end
         end
 
         reply
-      rescue EOFError
+      rescue ::EOFError
         raise Errno::ECONNRESET
       end
 

data/lib/hiredis/version.rb

@@ -1,3 +1,3 @@
 module Hiredis
-  VERSION = "0.3.2"
+  VERSION = "0.4.1"
 end

metadata

@@ -1,39 +1,35 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: hiredis
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.4.1
   prerelease: 
-  version: 0.3.2
 platform: ruby
-authors: 
+authors:
 - Pieter Noordhuis
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-05-17 00:00:00 +02:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-10-26 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rake-compiler
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70311128546620 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
+      - !ruby/object:Gem::Version
         version: 0.7.1
   type: :development
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: *70311128546620
 description: Ruby extension that wraps Hiredis (blocking connection and reply parsing)
-email: 
+email:
 - pcnoordhuis@gmail.com
 executables: []
-
-extensions: 
+extensions:
 - ext/hiredis_ext/extconf.rb
 extra_rdoc_files: []
-
-files: 
+files:
 - ext/hiredis_ext/extconf.rb
 - ext/hiredis_ext/connection.c
 - ext/hiredis_ext/hiredis_ext.c
@@ -63,33 +59,28 @@ files:
 - lib/hiredis.rb
 - COPYING
 - Rakefile
-has_rdoc: true
 homepage: http://github.com/pietern/hiredis-rb
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Ruby extension that wraps Hiredis (blocking connection and reply parsing)
 test_files: []
-