hiredis 0.4.1-java

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,46 @@
+require "bundler"
+Bundler::GemHelper.install_tasks
+
+require "rake/testtask"
+require "rake/extensiontask"
+
+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")
+      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 :rebuild => [:clean, :compile]
+
+else
+
+  task :rebuild do
+    # no-op
+  end
+
+end
+
+task :default => [:rebuild, :test]
+
+desc "Run tests"
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

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

data/lib/hiredis/ruby/reader.rb

@@ -0,0 +1,164 @@
+require "hiredis/version"
+
+module Hiredis
+  module Ruby
+    class Reader
+
+      def initialize
+        @buffer = Buffer.new
+        @task = Task.new(@buffer)
+      end
+
+      def feed(data)
+        @buffer << data
+      end
+
+      def gets
+        reply = @task.process
+        @buffer.discard!
+        reply
+      end
+
+    protected
+
+      class Task
+
+        # Use lookup table to map reply types to methods
+        method_index = {}
+        method_index[?-] = :process_error_reply
+        method_index[?+] = :process_status_reply
+        method_index[?:] = :process_integer_reply
+        method_index[?$] = :process_bulk_reply
+        method_index[?*] = :process_multi_bulk_reply
+        METHOD_INDEX = method_index.freeze
+
+        attr_accessor :parent, :child
+        attr_accessor :multi_bulk
+
+        def initialize(buffer, parent = nil, depth = 0)
+          @buffer, @parent = buffer, parent
+
+          # Require 3 nested tasks
+          @child = Task.new(@buffer, self, depth + 1) if depth < 2
+        end
+
+        def root
+          parent ? parent.root : self
+        end
+
+        def reset!
+          @line = @type = @multi_bulk = nil
+        end
+
+        def process_error_reply
+          RuntimeError.new(@line)
+        end
+
+        def process_status_reply
+          @line
+        end
+
+        def process_integer_reply
+          @line.to_i
+        end
+
+        def process_bulk_reply
+          bulk_length = @line.to_i
+          return nil if bulk_length < 0
+
+          # Caught by caller function when false
+          @buffer.read(bulk_length, 2)
+        end
+
+        def process_multi_bulk_reply
+          multi_bulk_length = @line.to_i
+
+          if multi_bulk_length > 0
+            @multi_bulk ||= []
+
+            # We know the multi bulk is not complete when this path is taken.
+            while (element = child.process) != false
+              @multi_bulk << element
+              return @multi_bulk if @multi_bulk.length == multi_bulk_length
+            end
+
+            false
+          elsif multi_bulk_length == 0
+            []
+          else
+            nil
+          end
+        end
+
+        def process_protocol_error
+          raise "Protocol error"
+        end
+
+        def process
+          @line ||= @buffer.read_line
+          return false if @line == false
+
+          @type ||= @line.slice!(0)
+          reply = send(METHOD_INDEX[@type] || :process_protocol_error)
+
+          reset! if reply != false
+          reply
+        end
+      end
+
+      class Buffer
+
+        CRLF = "\r\n".freeze
+
+        def initialize
+          @buffer = ""
+          @length = @pos = 0
+        end
+
+        def <<(data)
+          @length += data.length
+          @buffer << data
+        end
+
+        def length
+          @length
+        end
+
+        def empty?
+          @length == 0
+        end
+
+        def discard!
+          if @length == 0
+            @buffer = ""
+            @length = @pos = 0
+          else
+            if @pos >= 1024
+              @buffer.slice!(0, @pos)
+              @length -= @pos
+              @pos = 0
+            end
+          end
+        end
+
+        def read(bytes, skip = 0)
+          start = @pos
+          stop = start + bytes + skip
+          return false if @length < stop
+
+          @pos = stop
+          @buffer[start, bytes]
+        end
+
+        def read_line
+          start = @pos
+          stop = @buffer.index(CRLF, @pos)
+          return false unless stop
+
+          @pos = stop + 2 # include CRLF
+          @buffer[start, stop - start]
+        end
+      end
+    end
+  end
+end

data/lib/hiredis/version.rb

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

metadata

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