methodmissing_hiredis 0.4.6

data/ext/hiredis_ext/extconf.rb

@@ -0,0 +1,17 @@
+require 'mkmf'
+
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+hiredis_dir = File.expand_path(File.join(File.dirname(__FILE__), %w{.. .. vendor hiredis}))
+unless File.directory?(hiredis_dir)
+  STDERR.puts "vendor/hiredis missing, please checkout its submodule..."
+  exit 1
+end
+
+# Make sure hiredis is built...
+system("cd #{hiredis_dir} && make static")
+
+# Statically link to hiredis (mkmf can't do this for us)
+$CFLAGS << " -I#{hiredis_dir}"
+$LDFLAGS << " #{hiredis_dir}/libhiredis.a"
+create_makefile('hiredis/ext/hiredis_ext')

data/ext/hiredis_ext/hiredis_ext.c

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

data/ext/hiredis_ext/hiredis_ext.h

@@ -0,0 +1,37 @@
+#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 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,114 @@
+#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;
+
+/* 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->obj;
+        assert(TYPE(parent) == T_ARRAY);
+        rb_ary_store(parent,task->idx,v);
+    }
+    return (void*)v;
+}
+
+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) {
+        v = rb_funcall(rb_eRuntimeError,rb_intern("new"),1,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(redisReader *reader) {
+    VALUE root = (VALUE)reader->reply;
+    if (root != 0 && TYPE(root) == T_ARRAY) rb_gc_mark(root);
+}
+
+static VALUE reader_allocate(VALUE klass) {
+    redisReader *reader = redisReaderCreate();
+    reader->fn = &redisExtReplyObjectFunctions;
+    return Data_Wrap_Struct(klass, reader_mark, redisReaderFree, reader);
+}
+
+static VALUE reader_feed(VALUE klass, VALUE str) {
+    redisReader *reader;
+
+    if (TYPE(str) != T_STRING)
+        rb_raise(rb_eTypeError, "not a string");
+
+    Data_Get_Struct(klass, redisReader, reader);
+    redisReaderFeed(reader,RSTRING_PTR(str),(size_t)RSTRING_LEN(str));
+    return INT2NUM(0);
+}
+
+static VALUE reader_gets(VALUE klass) {
+    redisReader *reader;
+    VALUE reply;
+
+    Data_Get_Struct(klass, redisReader, reader);
+    if (redisReaderGetReply(reader,(void**)&reply) != REDIS_OK)
+        rb_raise(rb_eRuntimeError,"%s",reader->errstr);
+
+    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);
+
+    /* 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;
+    }
+}

data/lib/hiredis.rb

@@ -0,0 +1,2 @@
+require "hiredis/version"
+require "hiredis/connection"

data/lib/hiredis/connection.rb

@@ -0,0 +1,10 @@
+module Hiredis
+  begin
+    require "hiredis/ext/connection"
+    Connection = Ext::Connection
+  rescue LoadError
+    warn "WARNING: could not load hiredis extension, using (slower) pure Ruby implementation."
+    require "hiredis/ruby/connection"
+    Connection = Ruby::Connection
+  end
+end

data/lib/hiredis/ext/connection.rb

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

data/lib/hiredis/ext/reader.rb

@@ -0,0 +1,2 @@
+require "hiredis/ext/hiredis_ext"
+require "hiredis/version"

data/lib/hiredis/reader.rb

@@ -0,0 +1,10 @@
+module Hiredis
+  begin
+    require "hiredis/ext/reader"
+    Reader = Ext::Reader
+  rescue LoadError
+    warn "WARNING: could not load hiredis extension, using (slower) pure Ruby implementation."
+    require "hiredis/ruby/reader"
+    Reader = Ruby::Reader
+  end
+end

data/lib/hiredis/ruby/connection.rb

@@ -0,0 +1,298 @@
+require "socket"
+require "hiredis/ruby/reader"
+require "hiredis/version"
+
+module Hiredis
+  module Ruby
+    class Connection
+
+      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
+
+      end
+
+      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
+            Timeout.timeout(timeout) do
+              sock = UNIXSocket.new(path)
+            end
+          rescue SocketError => se
+            raise se.message
+          rescue Timeout::Error
+            raise Errno::ETIMEDOUT
+          end
+
+          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
+
+        nil
+      end
+
+      def disconnect
+        @sock.close
+      rescue
+      ensure
+        @sock = nil
+      end
+
+      def timeout=(usecs)
+        raise ArgumentError.new("timeout cannot be negative") if usecs < 0
+
+        if usecs == 0
+          @timeout = nil
+        else
+          @timeout = usecs / 1_000_000.0
+        end
+
+        nil
+      end
+
+      def fileno
+        raise "not connected" unless connected?
+
+        @sock.fileno
+      end
+
+      COMMAND_DELIMITER = "\r\n".freeze
+
+      def write(args)
+        command = []
+        command << "*#{args.size}"
+        args.each do |arg|
+          arg = arg.to_s
+          command << "$#{string_size arg}"
+          command << arg
+        end
+
+        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
+          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
+        raise Errno::ECONNRESET
+      end
+
+    protected
+
+      if "".respond_to?(:bytesize)
+        def string_size(string)
+          string.to_s.bytesize
+        end
+      else
+        def string_size(string)
+          string.to_s.size
+        end
+      end
+    end
+  end
+end