oxblood 0.1.0.dev1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e3f412e0d96b8bf2a8520c3bea9465376bf3f5ea
+  data.tar.gz: fcbe20525510727bd767ff3e134ae35f8d7572cc
+SHA512:
+  metadata.gz: 16ff977840a0feea5e931f0427e1f5bd8afa67336964b180a7dc166f5df6a042efde3251c9a1abfd65518aa147fbd8c1a8515dd77f89579c6997d6857288bc69
+  data.tar.gz: 791cd9fea4d673513a28b2e81f16b554ecb216c628cfbb97c9647715be065a8a34dc782aea4d6c06f4bc048cade2d9df9a2aced7ba43da8ab02cbf10a6321a3d

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/tmp/
+/benchmarks/Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.yardopts

@@ -0,0 +1 @@
+--no-private --protected

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Konstantin Shabanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+# Oxblood
+
+An experimental Redis Ruby client.
+
+## Usage
+
+### Standalone
+
+```ruby
+require 'oxblood'
+pool = Oxblood::Pool.new(size: 8)
+pool.with { |c| c.ping }
+```
+
+### As [redis-rb](https://github.com/redis/redis-rb) driver
+
+```ruby
+[1] pry(main)> require 'redis/connection/oxblood'
+=> true
+[2] pry(main)> require 'redis'
+=> true
+# For implicit usage connection should be required before redis gem
+[3] pry(main)> Redis.new.client.options[:driver]
+=> Redis::Connection::Oxblood
+# Explicitly
+[4] pry(main)> Redis.new(driver: :oxblood).client.options[:driver]
+=> Redis::Connection::Oxblood
+```
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/etehtsea/oxblood).
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+task default: :spec

data/benchmarks/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'oxblood', path: '..'
+gem 'benchmark-ips'
+gem 'redis'

data/benchmarks/serializer.rb

@@ -0,0 +1,17 @@
+require 'benchmark/ips'
+require 'oxblood/protocol'
+require 'redis/connection/command_helper'
+
+CommandHelper = Object.new.tap { |o| o.extend Redis::Connection::CommandHelper }
+
+command = [:set, 'foo', ['bar', Float::INFINITY, -Float::INFINITY, 3]]
+
+p CommandHelper.build_command(command)
+p Oxblood::Protocol.build_command(command)
+raise unless CommandHelper.build_command(command) == Oxblood::Protocol.build_command(command)
+
+Benchmark.ips do |x|
+  x.config(warmup: 20, benchmark: 10)
+  x.report('redis-ruby') { CommandHelper.build_command(command) }
+  x.report('Oxblood') { Oxblood::Protocol.build_command(command) }
+end

data/lib/oxblood.rb

@@ -0,0 +1,7 @@
+require 'oxblood/version'
+require 'oxblood/protocol'
+require 'oxblood/connection'
+require 'oxblood/pool'
+
+module Oxblood
+end

data/lib/oxblood/buffered_io.rb

@@ -0,0 +1,46 @@
+module Oxblood
+  # @private
+  class BufferedIO
+    def initialize(socket)
+      @socket = socket
+      @buffer = String.new
+    end
+
+    def gets(separator, timeout)
+      crlf = nil
+
+      while (crlf = @buffer.index(separator)) == nil
+        @buffer << _read_from_socket(1024, timeout)
+      end
+
+      @buffer.slice!(0, crlf + separator.bytesize)
+    end
+
+    def read(nbytes, timeout)
+      result = @buffer.slice!(0, nbytes)
+
+      while result.bytesize < nbytes
+        result << _read_from_socket(nbytes - result.bytesize, timeout)
+      end
+
+      result
+    end
+
+    private
+
+    def _read_from_socket(nbytes, timeout)
+      begin
+        @socket.read_nonblock(nbytes)
+      rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+        if IO.select([@socket], nil, nil, timeout)
+          retry
+        else
+          raise Connection::TimeoutError
+        end
+      end
+
+    rescue EOFError
+      raise Errno::ECONNRESET
+    end
+  end
+end

data/lib/oxblood/command.rb

@@ -0,0 +1,90 @@
+module Oxblood
+  module Command
+    class << self
+      def hdel(key, fields)
+        serialize([:HDEL, key, fields])
+      end
+
+      def hexists(key, field)
+        serialize([:HEXISTS, key, field])
+      end
+
+      def hmset(key, *args)
+        serialize(args.unshift(:HMSET, key))
+      end
+
+      def hget(key, field)
+        serialize([:HGET, key, field])
+      end
+
+      def hmget(key, *fields)
+        serialize(fields.unshift(:HMGET, key))
+      end
+
+      def hgetall(key)
+        serialize([:HGETALL, key])
+      end
+
+      # ------------------ Strings ---------------------
+
+      # ------------------ Connection ---------------------
+
+      def ping(message = nil)
+        command = [:PING]
+        command << message if message
+
+        serialize(command)
+      end
+
+      # ------------------ Server ---------------------
+
+      def info(section = nil)
+        command = [:INFO]
+        command << section if section
+
+        serialize(command)
+      end
+
+      # ------------------ Keys ------------------------
+
+      def del(*keys)
+        serialize(keys.unshift(:DEL))
+      end
+
+      def keys(pattern)
+        serialize([:KEYS, pattern])
+      end
+
+      def expire(key, seconds)
+        serialize([:EXPIRE, key, seconds])
+      end
+
+      # ------------------ Sets ------------------------
+
+      def sadd(key, *members)
+        serialize(members.unshift(:SADD, key))
+      end
+
+      def sunion(*keys)
+        serialize(keys.unshift(:SUNION))
+      end
+
+      # ------------------ Sorted Sets -----------------
+
+      def zadd(key, *args)
+        serialize(args.unshift(:ZADD, key))
+      end
+
+      # @todo Support optional args (WITHSCORES/LIMIT)
+      def zrangebyscore(key, min, max)
+        serialize([:ZRANGEBYSCORE, key, min, max])
+      end
+
+      private
+
+      def serialize(command)
+        Protocol.build_command(command)
+      end
+    end
+  end
+end

data/lib/oxblood/connection.rb

@@ -0,0 +1,137 @@
+require 'oxblood/protocol'
+require 'oxblood/buffered_io'
+
+module Oxblood
+  # Class responsible for connection maintenance
+  class Connection
+    TimeoutError = Class.new(RuntimeError)
+
+    class << self
+      # Open Redis connection
+      #
+      # @param [Hash] options Connection options
+      #
+      # @option (see .connect_tcp)
+      # @option (see .connect_unix)
+      def open(options = {})
+        options.key?(:path) ? connect_unix(options) : connect_tcp(options)
+      end
+
+      # Connect to Redis server through TCP
+      #
+      # @param [Hash] options Connection options
+      #
+      # @option options [String] :host ('localhost') Hostname or IP address to connect to
+      # @option options [Integer] :port (5672) Port Redis server listens on
+      # @option options [Float] :timeout (1.0) socket read timeout
+      # @option options [Float] :connect_timeout (1.0) socket connect timeout
+      #
+      # @return [Oxblood::Connection] connection instance
+      def connect_tcp(options = {})
+        host = options.fetch(:host, 'localhost')
+        port = options.fetch(:port, 6379)
+        timeout = options.fetch(:timeout, 1.0)
+        connect_timeout = options.fetch(:connect_timeout, 1.0)
+
+        socket = Socket.tcp(host, port, connect_timeout: connect_timeout)
+        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
+        new(socket, timeout)
+      end
+
+      # Connect to Redis server through UNIX socket
+      #
+      # @param [Hash] options Connection options
+      #
+      # @option options [String] :path UNIX socket path
+      # @option options [Float] :timeout (1.0) socket read timeout
+      #
+      # @raise [KeyError] if :path was not passed
+      #
+      # @return [Oxblood::Connection] connection instance
+      def connect_unix(options = {})
+        path = options.fetch(:path)
+        timeout = options.fetch(:timeout, 1.0)
+
+        socket = ::Socket.unix(path)
+        new(socket, timeout)
+      end
+    end
+
+    def initialize(socket, timeout)
+      @socket = socket
+      @timeout = timeout
+      @buffer = BufferedIO.new(socket)
+    end
+
+    # Send comand to Redis server
+    # @example send_command(['CONFIG', 'GET', '*']) => 32
+    # @param [Array] command Array of command name with it's args
+    # @return [Integer] Number of bytes written to socket
+    def send_command(command)
+      write(Protocol.build_command(command))
+    end
+
+    # FIXME: docs
+    def write(command)
+      @socket.write(command)
+    end
+
+    # Send command to Redis server and read response from it
+    # @example run_command(['PING']) => PONG
+    # @param [Array] command Array of command name with it's args
+    # @return #FIXME
+    def run_command(command)
+      send_command(command)
+      read_response
+    end
+
+    # True if connection is established
+    # @return [Boolean] connection status
+    def connected?
+      !!@socket
+    end
+
+    # Close connection to server
+    def close
+      @socket.close
+    ensure
+      @socket = nil
+    end
+
+    # Read number of bytes
+    # @param [Integer] nbytes number of bytes to read
+    # @return [String] read result
+    def read(nbytes)
+      @buffer.read(nbytes, @timeout)
+    end
+
+    # Read until separator
+    # @param [String] sep separator
+    # @return [String] read result
+    def gets(sep)
+      @buffer.gets(sep, @timeout)
+    end
+
+    # Set new read timeout
+    # @param [Float] timeout new timeout
+    def timeout=(timeout)
+      @timeout = timeout
+    end
+
+    # Read response from server
+    # @raise [TimeoutError] if timeout happen
+    # @note Will raise TimeoutError even if there is simply no response to read
+    #       from server. For example, if you are trying to read response before
+    #       sending command.
+    # @todo Raise specific error if server has nothing to answer.
+    def read_response
+      Protocol.parse(self)
+    end
+
+    # FIXME: docs
+    def read_responses(n)
+      Array.new(n) { read_response }
+    end
+  end
+end

data/lib/oxblood/pipeline.rb

@@ -0,0 +1,19 @@
+require 'oxblood/command'
+
+module Oxblood
+  class Pipeline < Session
+    def initialize(connection)
+      super
+      @commands = Array.new
+    end
+
+    def run(command)
+      @commands << command
+    end
+
+    def sync
+      @connection.write(@commands.join)
+      @connection.read_responses(@commands.size)
+    end
+  end
+end

data/lib/oxblood/pool.rb

@@ -0,0 +1,39 @@
+require 'connection_pool'
+require 'oxblood/session'
+require 'oxblood/pipeline'
+
+module Oxblood
+  class Pool
+    # Initialize connection pool
+    #
+    # @param [Hash] options Connection options
+    #
+    # @option options [Float] :timeout (1.0) Connection acquisition timeout.
+    # @option options [Integer] :size Pool size.
+    # @option options [Hash] :connection see {Connection.open}
+    def initialize(options = {})
+      timeout = options.fetch(:timeout, 1.0)
+      size = options.fetch(:size)
+
+      @pool = ConnectionPool.new(size: size, timeout: timeout) do
+        Connection.open(options.fetch(:connection, {}))
+      end
+    end
+
+    def with
+      conn = @pool.checkout
+      yield Session.new(conn)
+    ensure
+      @pool.checkin if conn
+    end
+
+    def pipelined
+      conn = @pool.checkout
+      pipeline = Pipeline.new(conn)
+      yield pipeline
+      pipeline.sync
+    ensure
+      @pool.checkin if conn
+    end
+  end
+end

data/lib/oxblood/protocol.rb

@@ -0,0 +1,128 @@
+module Oxblood
+  module Protocol
+    SerializerError = Class.new(RuntimeError)
+    ParserError = Class.new(RuntimeError)
+    RError = Class.new(RuntimeError)
+
+    SIMPLE_STRING = '+'.freeze
+    private_constant :SIMPLE_STRING
+
+    ERROR = '-'.freeze
+    private_constant :ERROR
+
+    INTEGER = ':'.freeze
+    private_constant :INTEGER
+
+    BULK_STRING = '$'.freeze
+    private_constant :BULK_STRING
+
+    ARRAY = '*'.freeze
+    private_constant :ARRAY
+
+    TERMINATOR = "\r\n".freeze
+    private_constant :TERMINATOR
+
+    EMPTY_ARRAY_RESPONSE = "#{ARRAY}0#{TERMINATOR}".freeze
+    private_constant :EMPTY_ARRAY_RESPONSE
+
+    NULL_ARRAY_RESPONSE = "#{ARRAY}-1#{TERMINATOR}".freeze
+    private_constant :NULL_ARRAY_RESPONSE
+
+    EMPTY_BULK_STRING_RESPONSE = "#{BULK_STRING}0#{TERMINATOR}#{TERMINATOR}".freeze
+    private_constant :EMPTY_BULK_STRING_RESPONSE
+
+    NULL_BULK_STRING_RESPONSE = "#{BULK_STRING}-1#{TERMINATOR}".freeze
+    private_constant :NULL_BULK_STRING_RESPONSE
+
+    EMPTY_STRING = ''.freeze
+    private_constant :EMPTY_STRING
+
+    EMPTY_ARRAY = [].freeze
+    private_constant :EMPTY_ARRAY
+
+    COMMAND_HEADER = [ARRAY, TERMINATOR].join.freeze
+    private_constant :COMMAND_HEADER
+
+    class << self
+      # Parse redis response
+      # @see http://redis.io/topics/protocol
+      # @raise [ParserError] if unable to parse response
+      # @param [#read, #gets] io IO or IO-like object to read from
+      # @return [String, RError, Integer, Array]
+      def parse(io)
+        line = io.gets(TERMINATOR)
+
+        case line[0]
+        when SIMPLE_STRING
+          line[1..-3]
+        when ERROR
+          RError.new(line[1..-3])
+        when INTEGER
+          line[1..-3].to_i
+        when BULK_STRING
+          return if line == NULL_BULK_STRING_RESPONSE
+
+          body_length = line[1..-1].to_i
+
+          case body_length
+          when -1 then nil
+          when 0 then
+            # discard CRLF
+            io.read(2)
+            EMPTY_STRING
+          else
+            # string length plus CRLF
+            body = io.read(body_length + 2)
+            body[0..-3]
+          end
+        when ARRAY
+          return if line == NULL_ARRAY_RESPONSE
+          return EMPTY_ARRAY if line == EMPTY_ARRAY_RESPONSE
+
+          size = line[1..-1].to_i
+
+          Array.new(size) { parse(io) }
+        else
+          raise ParserError.new('Unsupported response type')
+        end
+      end
+
+      # Serialize command to string according to Redis Protocol
+      # @note Redis don't support nested arrays
+      # @note Written in non-idiomatic ruby without error handling due to
+      #       performance reasons
+      # @see http://www.redis.io/topics/protocol#sending-commands-to-a-redis-server
+      # @raise [SerializerError] if unable to serialize given command
+      # @param [Array] command array consisting of redis command and arguments
+      # @return [String] serialized command
+      def build_command(command)
+        result = COMMAND_HEADER.dup
+        size = 0
+        command.each do |c|
+          if Array === c
+            c.each do |e|
+              append!(e, result)
+              size += 1
+            end
+          else
+            append!(c, result)
+            size += 1
+          end
+        end
+
+        result.insert(1, size.to_s)
+      end
+
+      private
+
+      def append!(elem, command)
+        elem = elem.to_s
+        command << BULK_STRING
+        command << elem.bytesize.to_s
+        command << TERMINATOR
+        command << elem
+        command << TERMINATOR
+      end
+    end
+  end
+end

data/lib/oxblood/session.rb

@@ -0,0 +1,203 @@
+require 'oxblood/connection'
+require 'oxblood/command'
+
+module Oxblood
+  class Session
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # ------------------ Hashes ---------------------
+
+    # Removes the specified fields from the hash stored at key
+    # @see http://redis.io/commands/hdel
+    #
+    # @param [String] key under which hash is stored
+    # @param [Array<#to_s>] fields to delete
+    #
+    # @return [Integer] the number of fields that were removed from the hash
+    def hdel(key, fields)
+      run(cmd.hdel(key, fields))
+    end
+
+    # Returns if field is an existing field in the hash stored at key
+    # @see http://redis.io/commands/hexists
+    #
+    # @param [String] key under which hash is stored
+    # @param [String] field to check for existence
+    #
+    # @return [Boolean] do hash contains field or not
+    def hexists(key, field)
+      1 == run(cmd.hexists(key, field))
+    end
+
+    # Set multiple hash fields to multiple values
+    # @see http://redis.io/commands/hmset
+    #
+    # @param [String] key under which store hash
+    # @param [[String, String], Array<[String, String]>] args fields and values
+    #
+    # @return [String] 'OK'
+    def hmset(key, *args)
+      run(cmd.hmset(key, *args))
+    end
+
+    # Get the value of a hash field
+    # @see http://redis.io/commands/hget
+    #
+    # @param [String] key under which hash is stored
+    # @param [String] field name
+    #
+    # @return [String, nil] the value associated with field
+    #   or nil when field is not present in the hash or key does not exist.
+    def hget(key, field)
+      run(cmd.hget(key, field))
+    end
+
+    # Get the field values of all given hash fields
+    # @see http://redis.io/commands/hmget
+    #
+    # @param [String] key under which hash is stored
+    # @param [String, Array<String>] fields to get
+    #
+    # @return [Array] list of values associated with the given fields,
+    #   in the same order as they are requested.
+    def hmget(key, *fields)
+      run(cmd.hmget(key, *fields))
+    end
+
+    # Get all the fields and values in a hash
+    # @see http://redis.io/commands/hgetall
+    #
+    # @param [String] key under which hash is stored
+    #
+    # @return [Hash] of fields and their values
+    def hgetall(key)
+      Hash[*run(cmd.hgetall(key))]
+    end
+
+    # ------------------ Strings ---------------------
+
+    # ------------------ Connection ---------------------
+
+    # Returns PONG if no argument is provided, otherwise return a copy of
+    # the argument as a bulk
+    # @see http://redis.io/commands/ping
+    #
+    # @param [String] message to return
+    #
+    # @return [String] message passed as argument
+    def ping(message = nil)
+      run(cmd.ping(message))
+    end
+
+    # ------------------ Server ---------------------
+
+    # Returns information and statistics about the server in a format that is
+    # simple to parse by computers and easy to read by humans
+    # @see http://redis.io/commands/info
+    #
+    # @param [String] section used to select a specific section of information
+    def info(section = nil)
+      command = [:INFO]
+      command << section if section
+
+      response = run(cmd.info(section))
+      # FIXME: Parse response
+    end
+
+    # ------------------ Keys ------------------------
+
+    # Delete a key
+    # @see http://redis.io/commands/del
+    #
+    # @param [String, Array<String>] keys to delete
+    #
+    # @return [Integer] the number of keys that were removed
+    def del(*keys)
+      run(cmd.del(*keys))
+    end
+
+    # Find all keys matching the given pattern
+    # @see http://redis.io/commands/keys
+    #
+    # @param [String] pattern used to match keys
+    def keys(pattern)
+      run(cmd.keys(pattern))
+    end
+
+    # Set a key's time to live in seconds
+    # @see http://redis.io/commands/expire
+    #
+    # @param [String] key to expire
+    # @param [Integer] seconds number of seconds
+    #
+    # @return [Integer] 1 if the timeout was set. 0 if key does not exist or
+    #   the timeout could not be set.
+    def expire(key, seconds)
+      run(cmd.expire(key, seconds))
+    end
+
+    # ------------------ Sets ------------------------
+
+    # Add one or more members to a set
+    # @see http://redis.io/commands/sadd
+    #
+    # @param [String] key under which store set
+    # @param [String, Array<String>] members to store
+    #
+    # @return [Integer] the number of elements that were added to the set,
+    #   not including all the elements already present into the set.
+    def sadd(key, *members)
+      run(cmd.sadd(key, *members))
+    end
+
+    # Add multiple sets
+    # @see http://redis.io/commands/sunion
+    #
+    # @param [String, Array<String>] keys
+    #
+    # @return [Array] list with members of the resulting set
+    def sunion(*keys)
+      run(cmd.sunion(*keys))
+    end
+
+    # ------------------ Sorted Sets -----------------
+
+    # Add one or more members to a sorted set, or update its score if it already
+    # exists.
+    # @see http://redis.io/commands/zadd
+    #
+    # @todo Add support for zadd options
+    #   http://redis.io/commands/zadd#zadd-options-redis-302-or-greater
+    #
+    # @param [String] key under which store set
+    # @param [[Float, String], Array<[Float, String]>] args scores and members
+    def zadd(key, *args)
+      run(cmd.zadd(key, *args))
+    end
+
+    # Return a range of members in a sorted set, by score
+    # @see http://redis.io/commands/zrangebyscore
+    #
+    # @todo Support optional args (WITHSCORES/LIMIT)
+    #
+    # @param [String] key under which set is stored
+    # @param [String] min value
+    # @param [String] max value
+    def zrangebyscore(key, min, max)
+      run(cmd.zrangebyscore(key, min, max))
+    end
+
+    protected
+
+    def cmd
+      Command
+    end
+
+    def run(command)
+      @connection.write(command)
+      @connection.read_response
+    end
+  end
+end

data/lib/oxblood/version.rb

@@ -0,0 +1,3 @@
+module Oxblood
+  VERSION = '0.1.0.dev1'
+end

data/lib/redis/connection/oxblood.rb

@@ -0,0 +1,57 @@
+require 'redis/connection/registry'
+require 'redis/errors'
+require 'oxblood'
+
+class Redis
+  module Connection
+    class Oxblood
+      def self.connect(config)
+        conn_type = config[:scheme] == 'unix' ? :unix : :tcp
+        connection = ::Oxblood::Connection.public_send(:"connect_#{conn_type}", config)
+
+        new(connection)
+      end
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def connected?
+        @connection && @connection.connected?
+      end
+
+      def timeout=(timeout)
+        @connection.timeout = timeout > 0 ? timeout : nil
+      end
+
+      def disconnect
+        @connection.close
+      end
+
+      def write(command)
+        @connection.send_command(command)
+      end
+
+      def read
+        reply = @connection.read_response
+        reply = encode(reply) if reply.is_a?(String)
+        reply = CommandError.new(reply.message) if reply.is_a?(::Oxblood::Protocol::RError)
+        reply
+      rescue ::Oxblood::Protocol::ParserError => e
+        raise Redis::ProtocolError.new(e.message)
+      end
+
+      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
+
+Redis::Connection.drivers << Redis::Connection::Oxblood

data/oxblood.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'oxblood/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'oxblood'
+  spec.version       = Oxblood::VERSION
+  spec.authors       = ['Konstantin Shabanov']
+  spec.email         = ['etehtsea@gmail.com']
+
+  spec.summary       = 'A Ruby Redis client'
+  spec.description   = 'An experimental Ruby Redis client'
+  spec.homepage      = 'https://github.com/etehtsea/oxblood'
+  spec.license       = 'MIT'
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'connection_pool'
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', "~> 3.4"
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'yard'
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: oxblood
+version: !ruby/object:Gem::Version
+  version: 0.1.0.dev1
+platform: ruby
+authors:
+- Konstantin Shabanov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An experimental Ruby Redis client
+email:
+- etehtsea@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".yardopts"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmarks/Gemfile
+- benchmarks/serializer.rb
+- lib/oxblood.rb
+- lib/oxblood/buffered_io.rb
+- lib/oxblood/command.rb
+- lib/oxblood/connection.rb
+- lib/oxblood/pipeline.rb
+- lib/oxblood/pool.rb
+- lib/oxblood/protocol.rb
+- lib/oxblood/session.rb
+- lib/oxblood/version.rb
+- lib/redis/connection/oxblood.rb
+- oxblood.gemspec
+homepage: https://github.com/etehtsea/oxblood
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.4
+signing_key: 
+specification_version: 4
+summary: A Ruby Redis client
+test_files: []
+has_rdoc: