gorsuch-redis 3.0.0.rc1

data/examples/unicorn/config.ru

@@ -0,0 +1,3 @@
+run lambda { |env|
+  [200, {"Content-Type" => "text/plain"}, [Redis.current.randomkey]]
+}

data/examples/unicorn/unicorn.rb

@@ -0,0 +1,20 @@
+require "redis"
+
+worker_processes 3
+
+# If you set the connection to Redis *before* forking,
+# you will cause forks to share a file descriptor.
+#
+# This causes a concurrency problem by which one fork
+# can read or write to the socket while others are
+# performing other operations.
+#
+# Most likely you'll be getting ProtocolError exceptions
+# mentioning a wrong initial byte in the reply.
+#
+# Thus we need to connect to Redis after forking the
+# worker processes.
+
+after_fork do |server, worker|
+  Redis.current.quit
+end

data/lib/redis/client.rb

@@ -0,0 +1,303 @@
+require "redis/errors"
+
+class Redis
+  class Client
+    attr_accessor :uri, :db, :logger
+    attr :timeout
+    attr :connection
+    attr :command_map
+
+    def initialize(options = {})
+      @uri = options[:uri]
+
+      if scheme == 'unix'
+        @db = 0
+      else
+        @db = uri.path[1..-1].to_i
+      end
+
+      @timeout = (options[:timeout] || 5).to_f
+      @logger = options[:logger]
+      @reconnect = true
+      @connection = Connection.drivers.last.new
+      @command_map = {}
+    end
+
+    def connect
+      establish_connection
+      call [:auth, password] if password
+      call [:select, @db] if @db != 0
+      self
+    end
+
+    def id
+      safe_uri
+    end
+
+    def safe_uri
+      temp_uri = @uri
+      temp_uri.user = nil
+      temp_uri.password = nil
+      temp_uri
+    end
+
+    def host
+      @uri.host
+    end 
+    
+    def password
+      @uri.password
+    end
+
+    def path
+      @uri.path
+    end
+
+    def port
+      @uri.port
+    end
+
+    def scheme
+      @uri.scheme
+    end
+
+    def call(command, &block)
+      reply = process([command]) { read }
+      raise reply if reply.is_a?(CommandError)
+
+      if block
+        block.call(reply)
+      else
+        reply
+      end
+    end
+
+    def call_loop(command)
+      error = nil
+
+      result = without_socket_timeout do
+        process([command]) do
+          loop do
+            reply = read
+            if reply.is_a?(CommandError)
+              error = reply
+              break
+            else
+              yield reply
+            end
+          end
+        end
+      end
+
+      # Raise error when previous block broke out of the loop.
+      raise error if error
+
+      # Result is set to the value that the provided block used to break.
+      result
+    end
+
+    def call_pipeline(pipeline)
+      without_reconnect_wrapper = lambda do |&blk| blk.call end
+      without_reconnect_wrapper = lambda do |&blk|
+        without_reconnect(&blk)
+      end if pipeline.without_reconnect?
+
+      shutdown_wrapper = lambda do |&blk| blk.call end
+      shutdown_wrapper = lambda do |&blk|
+        begin
+          blk.call
+        rescue ConnectionError
+          # Assume the pipeline was sent in one piece, but execution of
+          # SHUTDOWN caused none of the replies for commands that were executed
+          # prior to it from coming back around.
+          nil
+        end
+      end if pipeline.shutdown?
+
+      without_reconnect_wrapper.call do
+        shutdown_wrapper.call do
+          pipeline.finish(call_pipelined(pipeline.commands))
+        end
+      end
+    end
+
+    def call_pipelined(commands)
+      return [] if commands.empty?
+
+      # The method #ensure_connected (called from #process) reconnects once on
+      # I/O errors. To make an effort in making sure that commands are not
+      # executed more than once, only allow reconnection before the first reply
+      # has been read. When an error occurs after the first reply has been
+      # read, retrying would re-execute the entire pipeline, thus re-issuing
+      # already successfully executed commands. To circumvent this, don't retry
+      # after the first reply has been read successfully.
+
+      result = Array.new(commands.size)
+      reconnect = @reconnect
+
+      begin
+        process(commands) do
+          result[0] = read
+
+          @reconnect = false
+
+          (commands.size - 1).times do |i|
+            result[i + 1] = read
+          end
+        end
+      ensure
+        @reconnect = reconnect
+      end
+
+      result
+    end
+
+    def call_without_timeout(command, &blk)
+      without_socket_timeout do
+        call(command, &blk)
+      end
+    rescue ConnectionError
+      retry
+    end
+
+    def process(commands)
+      logging(commands) do
+        ensure_connected do
+          commands.each do |command|
+            if command_map[command.first]
+              command = command.dup
+              command[0] = command_map[command.first]
+            end
+
+            connection.write(command)
+          end
+
+          yield if block_given?
+        end
+      end
+    end
+
+    def connected?
+      connection.connected?
+    end
+
+    def disconnect
+      connection.disconnect if connection.connected?
+    end
+
+    def reconnect
+      disconnect
+      connect
+    end
+
+    def io
+      yield
+    rescue Errno::EAGAIN
+      raise TimeoutError, "Connection timed out"
+    rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, Errno::EBADF, Errno::EINVAL => e
+      raise ConnectionError, "Connection lost (%s)" % [e.class.name.split("::").last]
+    end
+
+    def read
+      io do
+        connection.read
+      end
+    end
+
+    def write(command)
+      io do
+        connection.write(command)
+      end
+    end
+
+    def without_socket_timeout
+      connect unless connected?
+
+      begin
+        self.timeout = 0
+        yield
+      ensure
+        self.timeout = @timeout if connected?
+      end
+    end
+
+    def without_reconnect
+      begin
+        original, @reconnect = @reconnect, false
+        yield
+      ensure
+        @reconnect = original
+      end
+    end
+
+  protected
+
+    def deprecated(old, new = nil, trace = caller[0])
+      message = "The method #{old} is deprecated and will be removed in 2.0"
+      message << " - use #{new} instead" if new
+      Redis.deprecate(message, trace)
+    end
+
+    def logging(commands)
+      return yield unless @logger && @logger.debug?
+
+      begin
+        commands.each do |name, *args|
+          @logger.debug("Redis >> #{name.to_s.upcase} #{args.join(" ")}")
+        end
+
+        t1 = Time.now
+        yield
+      ensure
+        @logger.debug("Redis >> %0.2fms" % ((Time.now - t1) * 1000))
+      end
+    end
+
+    def establish_connection
+      # Need timeout in usecs, like socket timeout.
+      timeout = Integer(@timeout * 1_000_000)
+
+      if @uri.scheme == 'unix'
+        connection.connect_unix(@uri.path, timeout)
+      else
+        connection.connect(@uri, timeout)
+      end
+
+      # If the timeout is set we set the low level socket options in order
+      # to make sure a blocking read will return after the specified number
+      # of seconds. This hack is from memcached ruby client.
+      self.timeout = @timeout
+
+    rescue Timeout::Error
+      raise CannotConnectError, "Timed out connecting to Redis on #{safe_uri}"
+    rescue Errno::ECONNREFUSED
+      raise CannotConnectError, "Error connecting to Redis on #{safe_uri} (ECONNREFUSED)"
+    end
+
+    def timeout=(timeout)
+      connection.timeout = Integer(timeout * 1_000_000)
+    end
+
+    def ensure_connected
+      tries = 0
+
+      begin
+        connect unless connected?
+        tries += 1
+
+        yield
+      rescue ConnectionError
+        disconnect
+
+        if tries < 2 && @reconnect
+          retry
+        else
+          raise
+        end
+      rescue Exception
+        disconnect
+        raise
+      end
+    end
+  end
+end

data/lib/redis/connection/command_helper.rb

@@ -0,0 +1,44 @@
+class Redis
+  module Connection
+    module CommandHelper
+
+      COMMAND_DELIMITER = "\r\n"
+
+      def build_command(args)
+        command = [nil]
+
+        args.each do |i|
+          if i.is_a? Array
+            i.each do |j|
+              j = j.to_s
+              command << "$#{j.bytesize}"
+              command << j
+            end
+          else
+            i = i.to_s
+            command << "$#{i.bytesize}"
+            command << i
+          end
+        end
+
+        command[0] = "*#{(command.length - 1) / 2}"
+
+        # Trailing delimiter
+        command << ""
+        command.join(COMMAND_DELIMITER)
+      end
+
+    protected
+
+      if defined?(Encoding::default_external)
+        def encode(string)
+          string.force_encoding(Encoding::default_external)
+        end
+      else
+        def encode(string)
+          string
+        end
+      end
+    end
+  end
+end

data/lib/redis/connection/hiredis.rb

@@ -0,0 +1,52 @@
+require "redis/connection/registry"
+require "redis/errors"
+require "hiredis/connection"
+require "timeout"
+
+class Redis
+  module Connection
+    class Hiredis
+      def initialize
+        @connection = ::Hiredis::Connection.new
+      end
+
+      def connected?
+        @connection.connected?
+      end
+
+      def timeout=(usecs)
+        @connection.timeout = usecs
+      end
+
+      def connect(uri, timeout)
+        @connection.connect(uri.host, uri.port, timeout)
+      rescue Errno::ETIMEDOUT
+        raise Timeout::Error
+      end
+
+      def connect_unix(path, timeout)
+        @connection.connect_unix(path, timeout)
+      rescue Errno::ETIMEDOUT
+        raise Timeout::Error
+      end
+
+      def disconnect
+        @connection.disconnect
+      end
+
+      def write(command)
+        @connection.write(command.flatten(1))
+      end
+
+      def read
+        reply = @connection.read
+        reply = CommandError.new(reply.message) if reply.is_a?(RuntimeError)
+        reply
+      rescue RuntimeError => err
+        raise ProtocolError.new(err.message)
+      end
+    end
+  end
+end
+
+Redis::Connection.drivers << Redis::Connection::Hiredis

data/lib/redis/connection/registry.rb

@@ -0,0 +1,12 @@
+class Redis
+  module Connection
+
+    # Store a list of loaded connection drivers in the Connection module.
+    # Redis::Client uses the last required driver by default, and will be aware
+    # of the loaded connection drivers if the user chooses to override the
+    # default connection driver.
+    def self.drivers
+      @drivers ||= []
+    end
+  end
+end

data/lib/redis/connection/ruby.rb

@@ -0,0 +1,136 @@
+require "redis/connection/registry"
+require "redis/connection/command_helper"
+require "redis/errors"
+require "socket"
+
+class Redis
+  module Connection
+    class Ruby
+      include Redis::Connection::CommandHelper
+
+      MINUS    = "-".freeze
+      PLUS     = "+".freeze
+      COLON    = ":".freeze
+      DOLLAR   = "$".freeze
+      ASTERISK = "*".freeze
+
+      def initialize
+        @sock = nil
+      end
+
+      def connected?
+        !! @sock
+      end
+
+      def connect(uri, timeout)
+        with_timeout(timeout.to_f / 1_000_000) do
+          @sock = TCPSocket.new(uri.host, uri.port)
+          @sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+        end
+      end
+
+      def connect_unix(path, timeout)
+        with_timeout(timeout.to_f / 1_000_000) do
+          @sock = UNIXSocket.new(path)
+        end
+      end
+
+      def disconnect
+        @sock.close
+      rescue
+      ensure
+        @sock = nil
+      end
+
+      def timeout=(usecs)
+        secs   = Integer(usecs / 1_000_000)
+        usecs  = Integer(usecs - (secs * 1_000_000)) # 0 - 999_999
+
+        optval = [secs, usecs].pack("l_2")
+
+        begin
+          @sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
+          @sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
+        rescue Errno::ENOPROTOOPT
+        end
+      end
+
+      def write(command)
+        @sock.write(build_command(command))
+      end
+
+      def read
+        # We read the first byte using read() mainly because gets() is
+        # immune to raw socket timeouts.
+        reply_type = @sock.read(1)
+
+        raise Errno::ECONNRESET unless reply_type
+
+        format_reply(reply_type, @sock.gets)
+      end
+
+      def format_reply(reply_type, line)
+        case reply_type
+        when MINUS    then format_error_reply(line)
+        when PLUS     then format_status_reply(line)
+        when COLON    then format_integer_reply(line)
+        when DOLLAR   then format_bulk_reply(line)
+        when ASTERISK then format_multi_bulk_reply(line)
+        else raise ProtocolError.new(reply_type)
+        end
+      end
+
+      def format_error_reply(line)
+        CommandError.new(line.strip)
+      end
+
+      def format_status_reply(line)
+        line.strip
+      end
+
+      def format_integer_reply(line)
+        line.to_i
+      end
+
+      def format_bulk_reply(line)
+        bulklen = line.to_i
+        return if bulklen == -1
+        reply = encode(@sock.read(bulklen))
+        @sock.read(2) # Discard CRLF.
+        reply
+      end
+
+      def format_multi_bulk_reply(line)
+        n = line.to_i
+        return if n == -1
+
+        Array.new(n) { read }
+      end
+
+    protected
+
+      begin
+        require "system_timer"
+
+        def with_timeout(seconds, &block)
+          SystemTimer.timeout_after(seconds, &block)
+        end
+
+      rescue LoadError
+        if ! defined?(RUBY_ENGINE)
+          # MRI 1.8, all other interpreters define RUBY_ENGINE, JRuby and
+          # Rubinius should have no issues with timeout.
+          warn "WARNING: using the built-in Timeout class which is known to have issues when used for opening connections. Install the SystemTimer gem if you want to make sure the Redis client will not hang."
+        end
+
+        require "timeout"
+
+        def with_timeout(seconds, &block)
+          Timeout.timeout(seconds, &block)
+        end
+      end
+    end
+  end
+end
+
+Redis::Connection.drivers << Redis::Connection::Ruby