oxblood 0.1.0.dev3 → 0.1.0.dev4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2d7a859b01da306481014391452d354b78e733d9
-  data.tar.gz: b5b6a5ccc51f7b07c562c29b434a85f65b9bd4cd
+  metadata.gz: 8a369a489b3733b77b4742e0d35cbaf30f8a794f
+  data.tar.gz: 081150bc06a0c6c2d3dd280f7ac0405caabd46a2
 SHA512:
-  metadata.gz: c1dffe945b9bb71adec19fc0f33a6847ca90fa325d061f699e7b784ced2aedcc4ec0f7685a17764e94db4f2ca513e830f0233e7a379b89a75584409f08862ce0
-  data.tar.gz: 53ccf202c3821c309a5d7e4c998280f682f7197d54f9c2f2cb6e7295bd07acb7054a5b4df50086e7b604a91f2911301d79677f416dcd8dd046a2202ec561b42e
+  metadata.gz: 86727e0c5bcfb0960204d6bd5e516d21614a9fb992e9d1cfe7c424872c759dc2673e1faafd2f82ca7035f64524f6f46839498ff0811e018045c854bb6e32467c
+  data.tar.gz: 24d72c0595245b1f19950acd2f65ae1ce19c32a9eed0b37893e9543bda7fb42b48523bd55511e5c87150260f5926e5a7de9f4502bffdc7152ed2df6945e250e1

data/benchmarks/serializer.rb

@@ -5,13 +5,14 @@ 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)
+command_name = :set
+command_args = ['foo', ['bar', Float::INFINITY, -Float::INFINITY, 3]]
+p ch_result = CommandHelper.build_command(command)
+p ox_result = Oxblood::Protocol.build_command(command_name, *command_args)
+raise unless ch_result == ox_result
 
 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) }
+  x.report('Oxblood') { Oxblood::Protocol.build_command(command_name, *command_args) }
 end

data/lib/oxblood/connection.rb

@@ -63,11 +63,11 @@ module Oxblood
     end
 
     # Send comand to Redis server
-    # @example send_command(['CONFIG', 'GET', '*']) => 32
+    # @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))
+    def send_command(*command)
+      write(Protocol.build_command(*command))
     end
 
     # Write data to socket
@@ -78,10 +78,10 @@ module Oxblood
     end
 
     # Send command to Redis server and read response from it
-    # @example run_command(['PING']) => PONG
+    # @example run_command('PING') => PONG
     # @param [Array] command Array of command name with it's args
-    def run_command(command)
-      send_command(command)
+    def run_command(*command)
+      send_command(*command)
       read_response
     end
 

data/lib/oxblood/pipeline.rb

@@ -1,5 +1,3 @@
-require 'oxblood/command'
-
 module Oxblood
   class Pipeline < Session
     def initialize(connection)
@@ -12,7 +10,8 @@ module Oxblood
     end
 
     def sync
-      @connection.write(@commands.join)
+      serialized_commands = @commands.map { |c| serialize(command) }
+      @connection.write(serialized_commands.join)
       @connection.read_responses(@commands.size)
     end
   end

data/lib/oxblood/protocol.rb

@@ -92,13 +92,19 @@ module Oxblood
       # @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
+      #
+      # @param [#to_s] command name
+      # @param [Array] args array consisting of command arguments
+      #
       # @return [String] serialized command
-      def build_command(command)
-        result = COMMAND_HEADER.dup
-        size = 0
-        command.each do |c|
+      def build_command(command = nil, *args)
+        return EMPTY_ARRAY_RESPONSE if command.nil?
+
+        result = append!(command, COMMAND_HEADER.dup)
+        size = 1
+        args.each do |c|
           if Array === c
             c.each do |e|
               append!(e, result)

data/lib/oxblood/session.rb

@@ -1,5 +1,3 @@
-require 'oxblood/command'
-
 module Oxblood
   class Session
     def initialize(connection)
@@ -18,7 +16,7 @@ module Oxblood
     #
     # @return [Integer] the number of fields that were removed from the hash
     def hdel(key, fields)
-      run(cmd.hdel(key, fields))
+      run(:HDEL, key, fields)
     end
 
     # Returns if field is an existing field in the hash stored at key
@@ -29,7 +27,7 @@ module Oxblood
     #
     # @return [Boolean] do hash contains field or not
     def hexists(key, field)
-      1 == run(cmd.hexists(key, field))
+      1 == run(:HEXISTS, key, field)
     end
 
     # Get the value of a hash field
@@ -41,7 +39,7 @@ module Oxblood
     # @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))
+      run(:HGET, key, field)
     end
 
     # Get all the fields and values in a hash
@@ -51,7 +49,7 @@ module Oxblood
     #
     # @return [Hash] of fields and their values
     def hgetall(key)
-      Hash[*run(cmd.hgetall(key))]
+      Hash[*run(:HGETALL, key)]
     end
 
     # Increment the integer value of a hash field by the given number
@@ -63,7 +61,7 @@ module Oxblood
     #
     # @return [Integer] the value at field after the increment operation
     def hincrby(key, field, increment)
-      run(cmd.hincrby(key, field, increment))
+      run(:HINCRBY, key, field, increment)
     end
 
     # Increment the float value of a hash field by the given number
@@ -75,7 +73,7 @@ module Oxblood
     #
     # @return [String] the value of field after the increment
     def hincrbyfloat(key, field, increment)
-      run(cmd.hincrbyfloat(key, field, increment))
+      run(:HINCRBYFLOAT, key, field, increment)
     end
 
     # Get all the keys in a hash
@@ -86,7 +84,7 @@ module Oxblood
     # @return [Array] list of fields in the hash, or an empty list when
     #   key does not exist.
     def hkeys(key)
-      run(cmd.hkeys(key))
+      run(:HKEYS, key)
     end
 
     # Get the number of keys in a hash
@@ -97,7 +95,7 @@ module Oxblood
     # @return [Integer] number of fields in the hash, or 0 when
     #   key does not exist.
     def hlen(key)
-      run(cmd.hlen(key))
+      run(:HLEN, key)
     end
 
     # Get the field values of all given hash fields
@@ -109,7 +107,7 @@ module Oxblood
     # @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))
+      run(*fields.unshift(:HMGET, key))
     end
 
     # Set multiple hash fields to multiple values
@@ -120,7 +118,7 @@ module Oxblood
     #
     # @return [String] 'OK'
     def hmset(key, *args)
-      run(cmd.hmset(key, *args))
+      run(*args.unshift(:HMSET, key))
     end
 
 
@@ -134,7 +132,7 @@ module Oxblood
     # @return [Integer] 1 if field is a new field in the hash and value was set.
     #   0 if field already exists in the hash and the value was updated.
     def hset(key, field, value)
-      run(cmd.hset(key, field, value))
+      run(:HSET, key, field, value)
     end
 
     # Set the value of a hash field, only if the field does not exist
@@ -147,7 +145,7 @@ module Oxblood
     # @return [Integer] 1 if field is a new field in the hash and value was set.
     #   0 if field already exists in the hash and no operation was performed.
     def hsetnx(key, field, value)
-      run(cmd.hsetnx(key, field, value))
+      run(:HSETNX, key, field, value)
     end
 
     # Get the length of the value of a hash field
@@ -159,7 +157,7 @@ module Oxblood
     # @return [Integer] the string length of the value associated with field,
     #   or 0 when field is not present in the hash or key does not exist at all.
     def hstrlen(key, field)
-      run(cmd.hstrlen(key, field))
+      run(:HSTRLEN, key, field)
     end
 
     # Get all values in a hash
@@ -170,7 +168,7 @@ module Oxblood
     # @return [Array] list of values in the hash, or an empty list when
     #   key does not exist
     def hvals(key)
-      run(cmd.hvals(key))
+      run(:HVALS, key)
     end
 
     # Incrementally iterate hash fields and associated values
@@ -191,7 +189,7 @@ module Oxblood
     #
     # @return [String] 'OK'
     def auth(password)
-      run(cmd.auth(password))
+      run(:AUTH, password)
     end
 
     # Like {#auth}, except that if error returned, raises it.
@@ -214,7 +212,7 @@ module Oxblood
     #
     # @return [String] message passed as argument
     def ping(message = nil)
-      run(cmd.ping(message))
+      message ? run(:PING, message) : run(:PING)
     end
 
     # Change the selected database for the current connection
@@ -224,7 +222,7 @@ module Oxblood
     #
     # @return [String] 'OK'
     def select(index)
-      run(cmd.select(index))
+      run(:SELECT, index)
     end
 
     # ------------------ Server ---------------------
@@ -235,7 +233,7 @@ module Oxblood
     #
     # @param [String] section used to select a specific section of information
     def info(section = nil)
-      run(cmd.info(section))
+      section ? run(:INFO, section) : run(:INFO)
       # FIXME: Parse response
     end
 
@@ -248,7 +246,7 @@ module Oxblood
     #
     # @return [Integer] the number of keys that were removed
     def del(*keys)
-      run(cmd.del(*keys))
+      run(*keys.unshift(:DEL))
     end
 
     # Find all keys matching the given pattern
@@ -256,7 +254,7 @@ module Oxblood
     #
     # @param [String] pattern used to match keys
     def keys(pattern)
-      run(cmd.keys(pattern))
+      run(:KEYS, pattern)
     end
 
     # Set a key's time to live in seconds
@@ -268,7 +266,7 @@ module Oxblood
     # @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))
+      run(:EXPIRE, key, seconds)
     end
 
     # ------------------ Sets ------------------------
@@ -282,7 +280,7 @@ module Oxblood
     # @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))
+      run(*members.unshift(:SADD, key))
     end
 
     # Add multiple sets
@@ -292,7 +290,7 @@ module Oxblood
     #
     # @return [Array] list with members of the resulting set
     def sunion(*keys)
-      run(cmd.sunion(*keys))
+      run(*keys.unshift(:SUNION))
     end
 
     # ------------------ Sorted Sets -----------------
@@ -307,7 +305,7 @@ module Oxblood
     # @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))
+      run(*args.unshift(:ZADD, key))
     end
 
     # Return a range of members in a sorted set, by score
@@ -319,17 +317,17 @@ module Oxblood
     # @param [String] min value
     # @param [String] max value
     def zrangebyscore(key, min, max)
-      run(cmd.zrangebyscore(key, min, max))
+      run(:ZRANGEBYSCORE, key, min, max)
     end
 
     protected
 
-    def cmd
-      Command
+    def serialize(*command)
+      Protocol.build_command(*command)
     end
 
-    def run(command)
-      @connection.write(command)
+    def run(*command)
+      @connection.write(serialize(*command))
       @connection.read_response
     end
 

data/lib/oxblood/version.rb

@@ -1,3 +1,3 @@
 module Oxblood
-  VERSION = '0.1.0.dev3'
+  VERSION = '0.1.0.dev4'
 end

data/lib/redis/connection/oxblood.rb

@@ -6,8 +6,11 @@ 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)
+        unless config[:path]
+          config = config.dup
+          config.delete(:path)
+        end
+        connection = ::Oxblood::Connection.open(config)
 
         new(connection)
       end
@@ -29,7 +32,7 @@ class Redis
       end
 
       def write(command)
-        @connection.send_command(command)
+        @connection.send_command(*command)
       end
 
       def read
@@ -39,6 +42,8 @@ class Redis
         reply
       rescue ::Oxblood::Protocol::ParserError => e
         raise Redis::ProtocolError.new(e.message)
+      rescue ::Oxblood::Connection::TimeoutError => e
+        raise Redis::TimeoutError.new(e.message)
       end
 
       if defined?(Encoding::default_external)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oxblood
 version: !ruby/object:Gem::Version
-  version: 0.1.0.dev3
+  version: 0.1.0.dev4
 platform: ruby
 authors:
 - Konstantin Shabanov
@@ -114,7 +114,6 @@ files:
 - 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

data/lib/oxblood/command.rb

@@ -1,138 +0,0 @@
-module Oxblood
-  module Command
-    class << self
-      #
-      # Hashes
-      #
-
-      def hdel(key, fields)
-        serialize([:HDEL, key, fields])
-      end
-
-      def hexists(key, field)
-        serialize([:HEXISTS, key, field])
-      end
-
-      def hget(key, field)
-        serialize([:HGET, key, field])
-      end
-
-      def hgetall(key)
-        serialize([:HGETALL, key])
-      end
-
-      def hincrby(key, field, increment)
-        serialize([:HINCRBY, key, field, increment])
-      end
-
-      def hincrbyfloat(key, field, increment)
-        serialize([:HINCRBYFLOAT, key, field, increment])
-      end
-
-      def hkeys(key)
-        serialize([:HKEYS, key])
-      end
-
-      def hlen(key)
-        serialize([:HLEN, key])
-      end
-
-      def hmget(key, *fields)
-        serialize(fields.unshift(:HMGET, key))
-      end
-
-      def hmset(key, *args)
-        serialize(args.unshift(:HMSET, key))
-      end
-
-      def hset(key, field, value)
-        serialize([:HSET, key, field, value])
-      end
-
-      def hsetnx(key, field, value)
-        serialize([:HSETNX, key, field, value])
-      end
-
-      def hstrlen(key, field)
-        serialize([:HSTRLEN, key, field])
-      end
-
-      def hvals(key)
-        serialize([:HVALS, key])
-      end
-
-      def hscan(_key, _cursor)
-        raise 'Not implemented!'
-      end
-
-      # ------------------ Strings ---------------------
-
-      # ------------------ Connection ---------------------
-
-      def auth(password)
-        serialize([:AUTH, password])
-      end
-
-      def ping(message = nil)
-        command = [:PING]
-        command << message if message
-
-        serialize(command)
-      end
-
-      def select(index)
-        serialize([:SELECT, index])
-      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