oxblood 0.1.0.dev6 → 0.1.0.dev7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d4ee25bdc593d1e5add8d8a72fe3a5672c761be
-  data.tar.gz: 83eb492c6fa4754533db829df5a8ae73502393cb
+  metadata.gz: 007983f13baaa6978b6db2a3fe4fc821abaa8f56
+  data.tar.gz: e96fbcaca9bcb69f95ddbae0d2ae606bf8fc0954
 SHA512:
-  metadata.gz: e92b901aa353d3db7398918a44721fa85d84f9b835c0478841402b0bc82afccd0435228800d19dcf7745e1f3f5ce03fcafe26881c2a6d72ef5f1be0652122ddf
-  data.tar.gz: 63d6b37b92ed32d333223afafaa776ae31fa07f49ed777ccb75fb3c8191665221360de1604fa24488c074ab182bedf4a43696254a0dbaae189d8113c1e479119
+  metadata.gz: 553a57f8b85f9407758c60cab222bbbfcc7804d74d1daad993bd46aec2099449159a3f8911bcb55e4957a62ae64d945ef7e6064bb121035ed7f09f683aa95b25
+  data.tar.gz: 0f7a5078313ffde39c70c4ffc2a87089881fcf4e8968591eaaf35bf4ee93c139a505e6572c924afb59eed75fe0e9308a78692c9a9e8fdac7d3f753116885e4c6

data/README.md

@@ -2,9 +2,9 @@
 
 [![Gem Version](https://badge.fury.io/rb/oxblood.svg)](https://badge.fury.io/rb/oxblood)
 [![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/github/etehtsea/oxblood/master/frames)
+[![Build Status](https://travis-ci.org/etehtsea/oxblood.svg?branch=master)](https://travis-ci.org/etehtsea/oxblood)
 [![Code Climate](https://codeclimate.com/github/etehtsea/oxblood/badges/gpa.svg)](https://codeclimate.com/github/etehtsea/oxblood)
 [![Test Coverage](https://codeclimate.com/github/etehtsea/oxblood/badges/coverage.svg)](https://codeclimate.com/github/etehtsea/oxblood/coverage)
-[![Issue Count](https://codeclimate.com/github/etehtsea/oxblood/badges/issue_count.svg)](https://codeclimate.com/github/etehtsea/oxblood)
 
 An experimental Redis Ruby client.
 
@@ -13,34 +13,34 @@ An experimental Redis Ruby client.
 - Ruby 2.2.2+
 - JRuby 9k+
 
+## Status
+
+- Commands:
+  - Cluster (0/20)
+  - Connection (4/5)
+  - Geo (0/6)
+  - Hashes (14/15)
+  - HyperLogLog (0/3)
+  - Keys (18/22)
+  - Lists (6/17)
+  - Pub/Sub (0/6)
+  - Scripting (0/7)
+  - Server (2/31)
+  - Sets (5/15)
+  - Sorted Sets (6/21)
+  - Strings (5/24)
+  - Transaction (0/5)
+- [Pipeling](http://www.rubydoc.info/github/etehtsea/oxblood/master/Oxblood/Pipeline)
+- [Connection pooling](http://www.rubydoc.info/github/etehtsea/oxblood/master/Oxblood/Pool)
+
 ## Usage
+As a starting point please look at [Oxblood::Pool](http://www.rubydoc.info/github/etehtsea/oxblood/master/Oxblood/Pool) documentation.
 
-### 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
-```
+## Documentation
+Documentation and usage examples are available on [Rubydoc](http://rubydoc.info/github/etehtsea/oxblood/master/frames).
 
 ## Continuous Integration
-
-[![Build Status](https://travis-ci.org/etehtsea/oxblood.svg?branch=master)](https://travis-ci.org/etehtsea/oxblood)
+You can check CI status at [Travis CI](https://travis-ci.org/etehtsea/oxblood.svg?branch=master).
 
 ## Contributing
 

data/benchmarks/pipeline.rb

@@ -0,0 +1,36 @@
+require 'redis'
+require 'oxblood'
+require 'benchmark'
+
+N = 100_000
+
+def benchmark(label, &blk)
+  sec = Benchmark.realtime(&blk)
+  puts [label, sec.round(3)].join(': ')
+end
+
+def redis_without
+  r = Redis.new
+  N.times { r.ping }
+end
+
+def redis_with
+  r = Redis.new
+  r.pipelined { N.times { r.ping } }
+end
+
+def oxblood_without
+  r = Oxblood::Session.new(Oxblood::Connection.new)
+  N.times { r.ping }
+end
+
+def oxblood_with
+  pipe = Oxblood::Pipeline.new(Oxblood::Connection.new)
+  N.times { pipe.ping }
+  pipe.sync
+end
+
+benchmark('redis without') { redis_without }
+benchmark('redis with') { redis_with }
+benchmark('oxblood without') { oxblood_without }
+benchmark('oxblood with') { oxblood_with }

data/lib/oxblood/buffered_io.rb

@@ -6,41 +6,7 @@ module Oxblood
       @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/connection.rb

@@ -1,65 +1,33 @@
 require 'oxblood/protocol'
-require 'oxblood/buffered_io'
+require 'oxblood/rsocket'
 require 'oxblood/session'
 
 module Oxblood
   # Class responsible for connection maintenance
   class Connection
-    TimeoutError = Class.new(RuntimeError)
-
-    class << self
-      # Open connection to Redis server
-      #
-      # @param [Hash] opts Connection options
-      #
-      # @option opts [Float] :timeout (1.0) socket read timeout
-      # @option opts [Integer] :db database number
-      # @option opts [String] :password
-      #
-      # @option opts [String] :host ('localhost') Hostname or IP address to connect to
-      # @option opts [Integer] :port (6379) Port Redis server listens on
-      # @option opts [Float] :connect_timeout (1.0) socket connect timeout
-      #
-      # @option opts [String] :path UNIX socket path
-      #
-      # @return [Oxblood::Connection] connection instance
-      def open(opts = {})
-        socket = if opts.key?(:path)
-          unix_socket(opts.fetch(:path))
-        else
-          host = opts.fetch(:host, 'localhost')
-          port = opts.fetch(:port, 6379)
-          connect_timeout = opts.fetch(:connect_timeout, 1.0)
-
-          tcp_socket(host, port, connect_timeout)
-        end
-
-        timeout = opts.fetch(:timeout, 1.0)
-
-        new(socket, timeout).tap do |conn|
-          session = Session.new(conn)
-          session.auth!(opts[:password]) if opts[:password]
-          session.select(opts[:db]) if opts[:db]
-        end
-      end
-
-      private
-
-      def unix_socket(path)
-        UNIXSocket.new(path)
-      end
-
-      def tcp_socket(host, port, connect_timeout)
-        Socket.tcp(host, port, connect_timeout: connect_timeout).tap do |sock|
-          sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-        end
-      end
-    end
-
-    def initialize(socket, timeout)
-      @socket = socket
-      @timeout = timeout
-      @buffer = BufferedIO.new(socket)
+    # @!attribute [r] socket
+    #   @return [RSocket] resilient socket
+    attr_reader :socket
+
+    # Initialize connection to Redis server
+    #
+    # @param [Hash] opts Connection options
+    #
+    # @option opts [Float] :timeout (1.0) socket read/write timeout
+    # @option opts [Integer] :db database number
+    # @option opts [String] :password
+    #
+    # @option opts [String] :host ('localhost') Hostname or IP address to connect to
+    # @option opts [Integer] :port (6379) Port Redis server listens on
+    # @option opts [Float] :connect_timeout (1.0) socket connect timeout
+    #
+    # @option opts [String] :path UNIX socket path
+    def initialize(opts = {})
+      @socket = RSocket.new(opts)
+
+      session = Session.new(self)
+      session.auth!(opts[:password]) if opts[:password]
+      session.select(opts[:db]) if opts[:db]
     end
 
     # Send comand to Redis server
@@ -67,14 +35,7 @@ module Oxblood
     # @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
-
-    # Write data to socket
-    # @param [#to_s] data given
-    # @return [Integer] the number of bytes written
-    def write(data)
-      @socket.write(data)
+      @socket.write(Protocol.build_command(*command))
     end
 
     # Send command to Redis server and read response from it
@@ -85,47 +46,14 @@ module Oxblood
       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
+    # @raise [RSocket::TimeoutError] if timeout happen
+    # @note Will raise RSocket::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)
+      Protocol.parse(@socket)
     end
 
     # Read several responses from server

data/lib/oxblood/pipeline.rb

@@ -20,7 +20,8 @@ module Oxblood
     # @return [Array] of responses
     def sync
       serialized_commands = @commands.map { |c| serialize(*c) }
-      @connection.write(serialized_commands.join)
+
+      @connection.socket.write(serialized_commands.join)
       @connection.read_responses(@commands.size)
     end
 

data/lib/oxblood/pool.rb

@@ -4,7 +4,11 @@ require 'oxblood/pipeline'
 require 'oxblood/connection'
 
 module Oxblood
-  # Connection pool to Redis server
+  # Create connection pool. For the most use cases this is entrypoint API.
+  #
+  # @example
+  #   pool = Oxblood::Pool.new(size: 8)
+  #   pool.with { |c| c.ping } # => 'PONG'
   class Pool
     # Initialize connection pool
     #
@@ -12,13 +16,13 @@ module Oxblood
     #
     # @option options [Float] :timeout (1.0) Connection acquisition timeout.
     # @option options [Integer] :size Pool size.
-    # @option options [Hash] :connection see {Connection.open}
+    # @option options [Hash] :connection see {Connection#initialize}
     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, {}))
+        Connection.new(options.fetch(:connection, {}))
       end
     end
 

data/lib/oxblood/rsocket.rb

@@ -0,0 +1,131 @@
+require 'io/wait'
+require 'socket'
+
+module Oxblood
+  # Thin socket wrapper made with resilience. Socket will be closed and
+  # automatically recreated in case of any errors (including timeout errors)
+  # in order to avoid inconsistent state.
+  class RSocket
+    TimeoutError = Class.new(RuntimeError)
+
+    # @!attribute [rw] timeout
+    #   @return [Numeric] timeout in seconds
+    attr_accessor :timeout
+
+    # Maintain socket
+    #
+    # @param [Hash] opts Connection options
+    #
+    # @option opts [Float] :timeout (1.0) socket read/write timeout
+    #
+    # @option opts [String] :host ('localhost') Hostname or IP address to connect to
+    # @option opts [Integer] :port (6379) Port Redis server listens on
+    # @option opts [Float] :connect_timeout (1.0) socket connect timeout
+    #
+    # @option opts [String] :path UNIX socket path
+    def initialize(opts = {})
+      @opts = opts
+      @timeout = opts.fetch(:timeout, 1.0)
+      @socket = create_socket(opts)
+      @buffer = String.new.encode!('ASCII-8BIT')
+    end
+
+    # Read number of bytes
+    # @param [Integer] nbytes number of bytes to read
+    # @return [String] read result
+    def read(nbytes)
+      result = @buffer.slice!(0, nbytes)
+
+      while result.bytesize < nbytes
+        result << readpartial(nbytes - result.bytesize)
+      end
+
+      result
+    end
+
+    # Read until separator
+    # @param [String] separator separator
+    # @return [String] read result
+    def gets(separator)
+      while (crlf = @buffer.index(separator)).nil?
+        @buffer << readpartial(1024)
+      end
+
+      @buffer.slice!(0, crlf + separator.bytesize)
+    end
+
+    # Write data to socket
+    # @param [String] data given
+    # @return [Integer] the number of bytes written
+    def write(data)
+      full_size = data.bytesize
+
+      while data.bytesize > 0
+        written = socket.write_nonblock(data, exception: false)
+
+        if written == :wait_writable
+          socket.wait_writable(@timeout) or fail_with_timeout!
+        else
+          data = data.byteslice(written..-1)
+        end
+      end
+
+      full_size
+    end
+
+    # Close connection to server
+    # @return [nil] always return nil
+    def close
+      @buffer.clear
+      socket.close
+    rescue IOError
+      ;
+    ensure
+      @socket = nil
+    end
+
+    # True if connection is established
+    # @return [Boolean] connection status
+    def connected?
+      !!@socket
+    end
+
+    private
+
+    def socket
+      @socket ||= create_socket(@opts)
+    end
+
+    def create_socket(opts)
+      if opts.key?(:path)
+        UNIXSocket.new(opts.fetch(:path))
+      else
+        host = opts.fetch(:host, 'localhost')
+        port = opts.fetch(:port, 6379)
+        connect_timeout = opts.fetch(:connect_timeout, 1.0)
+
+        Socket.tcp(host, port, connect_timeout: connect_timeout).tap do |sock|
+          sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        end
+      end
+    end
+
+    def readpartial(nbytes)
+      case data = socket.read_nonblock(nbytes, exception: false)
+      when String
+        return data
+      when :wait_readable
+        socket.wait_readable(@timeout) or fail_with_timeout!
+      when nil
+        close
+        raise Errno::ECONNRESET
+      end while true
+    end
+
+
+    def fail_with_timeout!
+      close
+      raise TimeoutError
+    end
+  end
+end

data/lib/oxblood/session.rb

@@ -1,4 +1,13 @@
 module Oxblood
+  # Implements usual Request/Response protocol
+  #
+  # @note {Session} don't maintain threadsafety! In multithreaded environment
+  #   please use {Pool}
+  #
+  # @example
+  #   conn = Oxblood::Connection.new
+  #   session = Oxblood::Session.new(conn)
+  #   session.ping # => 'PONG'
   class Session
     def initialize(connection)
       @connection = connection
@@ -174,9 +183,70 @@ module Oxblood
       run(:HVALS, key)
     end
 
-    # ------------------ Strings ---------------------
+    #
+    # Strings
+    #
+
+    # Get the value of a key
+    # @see http://redis.io/commands/get
+    #
+    # @param [String] key
+    #
+    # @return [String, nil] the value of key, or nil when key does not exists
+    def get(key)
+      run(:GET, key)
+    end
+
+    # Increment the integer value of a key by one
+    # @see http://redis.io/commands/incr
+    #
+    # @param [String] key
+    #
+    # @return [Integer] the value of key after the increment
+    # @return [RError] if the key contains a value of the wrong type or contains
+    #   a string that can not be represented as integer
+    def incr(key)
+      run(:INCR, key)
+    end
+
+    # Increment the integer value of a key by the given amount
+    # @see http://redis.io/commands/incrby
+    #
+    # @param [String] key
+    # @param [Integer] increment
+    #
+    # @return [Integer] the value of key after the increment
+    def incrby(key, increment)
+      run(:INCRBY, key, increment)
+    end
+
+    # Get the values of all the given keys
+    # @see http://redis.io/commands/mget
+    #
+    # @param [Array<String>] keys to retrieve
+    #
+    # @return [Array] list of values at the specified keys
+    def mget(*keys)
+      run(*keys.unshift(:MGET))
+    end
+
+    # Set the string value of a key
+    # @see http://redis.io/commands/set
+    #
+    # @todo Add support for set options
+    #   http://redis.io/commands/set#options
+    #
+    # @param [String] key
+    # @param [String] value
+    #
+    # @return [String] 'OK' if SET was executed correctly
+    def set(key, value)
+      run(:SET, key, value)
+    end
 
-    # ------------------ Connection ---------------------
+    #
+    # Connection
+    #
 
     # Authenticate to the server
     # @see http://redis.io/commands/auth
@@ -234,7 +304,17 @@ module Oxblood
       run(:SELECT, index)
     end
 
-    # ------------------ Server ---------------------
+    #
+    # Server
+    #
+
+    # Remove all keys from the current database
+    # @see http://redis.io/commands/flushdb
+    #
+    # @return [String] should always return 'OK'
+    def flushdb
+      run(:FLUSHDB)
+    end
 
     # Returns information and statistics about the server in a format that is
     # simple to parse by computers and easy to read by humans
@@ -247,7 +327,9 @@ module Oxblood
       section ? run(:INFO, section) : run(:INFO)
     end
 
-    # ------------------ Keys ------------------------
+    #
+    # Keys
+    #
 
     # Delete a key
     # @see http://redis.io/commands/del
@@ -457,7 +539,81 @@ module Oxblood
       run(:TYPE, key)
     end
 
-    # ------------------ Sets ------------------------
+    #
+    # Lists
+    #
+
+    # Get the length of a list
+    # @see http://redis.io/commands/llen
+    #
+    # @param [String] key
+    #
+    # @return [Integer] the length of the list at key
+    # @return [RError] if the value stored at key is not a list
+    def llen(key)
+      run(:LLEN, key)
+    end
+
+    # Remove and get the first element in a list
+    # @see http://redis.io/commands/lpop
+    #
+    # @param [String] key
+    #
+    # @return [String, nil] the value of the first element,
+    #   or nil when key does not exist.
+    def lpop(key)
+      run(:LPOP, key)
+    end
+
+    # Prepend one or multiple values to a list
+    # @see http://redis.io/commands/lpush
+    #
+    # @param [String] key
+    # @param [Array] values to prepend
+    #
+    # @return [Integer] the length of the list after the push operations
+    def lpush(key, *values)
+      run(*values.unshift(:LPUSH, key))
+    end
+
+    # Get a range of elements from a list
+    # @see http://redis.io/commands/lrange
+    #
+    # @param [String] key
+    # @param [Integer] start index
+    # @param [Integer] stop index
+    #
+    # @return [Array] list of elements in the specified range
+    def lrange(key, start, stop)
+      run(:LRANGE, key, start, stop)
+    end
+
+    # Remove and get the last element in a list
+    # @see http://redis.io/commands/rpop
+    #
+    # @param [String] key
+    #
+    # @return [String, nil] the value of the last element, or nil when key does
+    #   not exist
+    def rpop(key)
+      run(:RPOP, key)
+    end
+
+    # Append one or multiple values to a list
+    # @see http://redis.io/commands/rpush
+    #
+    # @param [String] key
+    # @param [Array] values to add
+    #
+    # @return [Integer] the length of the list after the push operation
+    # @return [RError] if key holds a value that is not a list
+    def rpush(key, *values)
+      run(*values.unshift(:RPUSH, key))
+    end
+
+    #
+    # Sets
+    #
 
     # Add one or more members to a set
     # @see http://redis.io/commands/sadd
@@ -471,6 +627,39 @@ module Oxblood
       run(*members.unshift(:SADD, key))
     end
 
+    # Get the number of members in a set
+    # @see http://redis.io/commands/scard
+    #
+    # @param [String] key
+    #
+    # @return [Integer] the cardinality (number of elements) of the set, or 0 if
+    #   key does not exist
+    def scard(key)
+      run(:SCARD, key)
+    end
+
+    # Get all the members in a set
+    # @see http://redis.io/commands/smembers
+    #
+    # @param [String] key
+    #
+    # @return [Array] all elements of the set
+    def smembers(key)
+      run(:SMEMBERS, key)
+    end
+
+    # Remove one or more members from a set
+    # @see http://redis.io/commands/srem
+    #
+    # @param [String] key
+    # @param [Array] members to remove
+    #
+    # @return [Integer] the number of members that were removed from the set,
+    #   not including non existing members
+    def srem(key, *members)
+      run(*members.unshift(:SREM, key))
+    end
+
     # Add multiple sets
     # @see http://redis.io/commands/sunion
     #
@@ -481,7 +670,9 @@ module Oxblood
       run(*keys.unshift(:SUNION))
     end
 
-    # ------------------ Sorted Sets -----------------
+    #
+    # Sorted Sets
+    #
 
     # Add one or more members to a sorted set, or update its score if it already
     # exists.
@@ -492,18 +683,59 @@ module Oxblood
     #
     # @param [String] key under which store set
     # @param [[Float, String], Array<[Float, String]>] args scores and members
+    #
+    # @return [Integer] The number of elements added to the sorted sets, not
+    #   including elements already existing for which the score was updated
     def zadd(key, *args)
       run(*args.unshift(:ZADD, key))
     end
 
+    # Get the number of members in a sorted set
+    # @see http://redis.io/commands/zcard
+    #
+    # @param [String] key
+    #
+    # @return [Integer] the cardinality (number of elements) of the sorted set,
+    #   or 0 if key does not exists
+    def zcard(key)
+      run(:ZCARD, key)
+    end
+
+    # Return a range of members in a sorted set, by index
+    # @see http://redis.io/commands/zrange
+    #
+    # @example
+    #   session.zrange('myzset', 0, -1)
+    #   # => ['one', 'two']
+    #
+    # @example
+    #   session.zrange('myzset', 0, -1, withscores: true)
+    #   # => [['one', '1'], ['two', '2']]
+    #
+    # @param [String] key
+    # @param [Integer] start index
+    # @param [Integer] stop index
+    # @param [Hash] opts
+    #
+    # @option opts [Boolean] :withscores (false) Return the scores of
+    #   the elements together with the elements
+    #
+    # @return [Array] list of elements in the specified range (optionally with
+    #   their scores, in case the :withscores option is given)
+    def zrange(key, start, stop, opts = {})
+      args = [:ZRANGE, key, start, stop]
+      args << :WITHSCORES if opts[:withscores]
+      run(*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
+    # @param [String] min score
+    # @param [String] max score
     #
     # @return [Array] list of elements in the specified score range
     def zrangebyscore(key, min, max)
@@ -522,6 +754,18 @@ module Oxblood
       run(*members.unshift(:ZREM, key))
     end
 
+    # Remove all members in a sorted set within the given scores
+    # @see http://redis.io/commands/zremrangebyscore
+    #
+    # @param [String] key
+    # @param [String] min score
+    # @param [String] max score
+    #
+    # @return [Integer] the number of elements removed
+    def zremrangebyscore(key, min, max)
+      run(:ZREMRANGEBYSCORE, key, min, max)
+    end
+
     protected
 
     def serialize(*command)
@@ -529,8 +773,7 @@ module Oxblood
     end
 
     def run(*command)
-      @connection.write(serialize(*command))
-      @connection.read_response
+      @connection.run_command(*command)
     end
 
     private

data/lib/oxblood/version.rb

@@ -1,3 +1,3 @@
 module Oxblood
-  VERSION = '0.1.0.dev6'
+  VERSION = '0.1.0.dev7'
 end

data/lib/redis/connection/oxblood.rb

@@ -10,7 +10,7 @@ class Redis
           config = config.dup
           config.delete(:path)
         end
-        connection = ::Oxblood::Connection.open(config)
+        connection = ::Oxblood::Connection.new(config)
 
         new(connection)
       end
@@ -20,15 +20,15 @@ class Redis
       end
 
       def connected?
-        @connection && @connection.connected?
+        @connection.socket && @connection.socket.connected?
       end
 
       def timeout=(timeout)
-        @connection.timeout = timeout > 0 ? timeout : nil
+        @connection.socket.timeout = timeout > 0 ? timeout : nil
       end
 
       def disconnect
-        @connection.close
+        @connection.socket.close
       end
 
       def write(command)
@@ -42,7 +42,7 @@ class Redis
         reply
       rescue ::Oxblood::Protocol::ParserError => e
         raise Redis::ProtocolError.new(e.message)
-      rescue ::Oxblood::Connection::TimeoutError => e
+      rescue ::Oxblood::RSocket::TimeoutError => e
         raise Redis::TimeoutError.new(e.message)
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oxblood
 version: !ruby/object:Gem::Version
-  version: 0.1.0.dev6
+  version: 0.1.0.dev7
 platform: ruby
 authors:
 - Konstantin Shabanov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-07 00:00:00.000000000 Z
+date: 2016-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -111,6 +111,7 @@ files:
 - README.md
 - Rakefile
 - benchmarks/Gemfile
+- benchmarks/pipeline.rb
 - benchmarks/serializer.rb
 - lib/oxblood.rb
 - lib/oxblood/buffered_io.rb
@@ -118,6 +119,7 @@ files:
 - lib/oxblood/pipeline.rb
 - lib/oxblood/pool.rb
 - lib/oxblood/protocol.rb
+- lib/oxblood/rsocket.rb
 - lib/oxblood/session.rb
 - lib/oxblood/version.rb
 - lib/redis/connection/oxblood.rb