em-redis 0.2.2 → 0.2.3

data/History.txt

@@ -7,7 +7,7 @@
 == 0.2 / 2009-12-15
 * rip off stock redis gem
 * sort is no longer compatible with 0.1 version
-* response of exists, sismember, sadd, srem, smove, zadd, zrem, move, setnx, del, renamenx, and expire is either true of false, not 0/1 as in 0.1
+* response of exists, sismember, sadd, srem, smove, zadd, zrem, move, setnx, del, renamenx, and expire is either true or false, not 0 or 1 as in 0.1
 * info returns hash of symbols now
 * lrem has different argument order
 

data/README.rdoc

@@ -23,26 +23,28 @@ Like any Deferrable eventmachine-based protocol implementation, using EM-Redis i
   require 'em-redis'
 
   EM.run do
-    redis = EM::Protocol::Redis.connect
-    error_callback = lambda {|code| puts "Error code: #{code}" }
-    redis.on_error error_callback
+    redis = EM::Protocols::Redis.connect
+    redis.errback do |code|
+      puts "Error code: #{code}"
+    end
     redis.set "a", "foo" do |response|
       redis.get "a" do |response|
         puts response
       end
     end
+    # We get pipelining for free
+    redis.set("b", "bar")
+    redis.get("a") do |response|
+      puts response # will be foo
+    end
   end
 
-To run live tests on a Redis server (currently compatible with 1.3)
-
-  rake redis:live_test
-
-To run a test of the underlying protocol implemention
+To run tests on a Redis server (currently compatible with 1.3)
 
-  rake redis:offline_test
+  rake
 
 Because the EM::Protocol::Memcached code used Bacon for testing, test code is
-currently in the form of bacon specs.  I'll port them to RSpec at some point.
+currently in the form of bacon specs.
 
 == REQUIREMENTS:
 

data/Rakefile

@@ -11,13 +11,15 @@ end
 ensure_in_path 'lib'
 require 'em-redis'
 
-task :default => ['redis:live_test', 'redis:offline_test']
+task :default => ['redis:test']
 
 Bones {
   name 'em-redis'
   authors ['Jonathan Broad', 'Eugene Pimenov']
   email 'libc@me.com'
-  url ''
+  url 'http://github.com/libc/em-redis'
+  summary 'An eventmachine-based implementation of the Redis protocol'
+  description summary
   version EMRedis::VERSION
 
   readme_file  'README.rdoc'
@@ -29,4 +31,11 @@ Bones {
   depend_on "em-spec", :development => true 
 }
 
+namespace :redis do
+  desc "Test em-redis against a live Redis"
+  task :test do
+    sh "bacon spec/live_redis_protocol_spec.rb spec/redis_commands_spec.rb spec/redis_protocol_spec.rb"
+  end
+end
+
 # EOF

data/lib/em-redis.rb

@@ -2,7 +2,7 @@
 module EMRedis
 
   # :stopdoc:
-  VERSION = '0.2.2'
+  VERSION = '0.2.3'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:

data/lib/em-redis/redis_protocol.rb

@@ -28,18 +28,22 @@ module EventMachine
         "sadd"      => true,
         "srem"      => true,
         "sismember" => true,
-        "rpoplpush" => true,
         "echo"      => true,
         "getset"    => true,
         "smove"     => true,
         "zadd"      => true,
+        "zincrby"   => true,
         "zrem"      => true,
-        "zscore"    => true
+        "zscore"    => true,
+        "hget"      => true,
+        "hdel"      => true,
+        "hexists"   => true
       }
 
       MULTI_BULK_COMMANDS = {
         "mset"      => true,
         "msetnx"    => true,
+        "hset"      => true,
         # these aliases aren't in redis gem
         "multi_get" => true
       }
@@ -60,7 +64,16 @@ module EventMachine
         "renamenx"  => BOOLEAN_PROCESSOR,
         "expire"    => BOOLEAN_PROCESSOR,
         "select"    => BOOLEAN_PROCESSOR, # not in redis gem
-        "keys"      => lambda{|r| r.split(" ")},
+        "hset"      => BOOLEAN_PROCESSOR,
+        "hdel"      => BOOLEAN_PROCESSOR,
+        "hexists"   => BOOLEAN_PROCESSOR,
+        "keys"      => lambda {|r|
+          if r.is_a?(Array)
+            r
+          else
+            r.split(" ")
+          end
+        },
         "info"      => lambda{|r|
           info = {}
           r.each_line {|kv|
@@ -68,6 +81,9 @@ module EventMachine
             info[k.to_sym] = v
           }
           info
+        }, 
+        "hgetall"   => lambda{|r|
+          Hash[*r]
         }
       }
 
@@ -105,12 +121,14 @@ module EventMachine
         "rename_unless_exists" => "renamenx",
         "type?"                => "type",
         "zset_add"             => "zadd",
-        "zset_count"           => 'zcard',
-        "zset_range_by_score"  => 'zrangebyscore',
-        "zset_reverse_range"   => 'zrevrange',
-        "zset_range"           => 'zrange',
-        "zset_delete"          => 'zrem',
-        "zset_score"           => 'zscore',
+        "zset_count"           => "zcard",
+        "zset_range_by_score"  => "zrangebyscore",
+        "zset_reverse_range"   => "zrevrange",
+        "zset_range"           => "zrange",
+        "zset_delete"          => "zrem",
+        "zset_score"           => "zscore",
+        "zset_incr_by"         => "zincrby",
+        "zset_increment_by"    => "zincrby",
         # these aliases aren't in redis gem
         "background_save"      => 'bgsave',
         "async_save"           => 'bgsave',
@@ -160,9 +178,9 @@ module EventMachine
 
       def set(key, value, expiry=nil)
         call_command([:set, key, value]) do |s|
-          expire(key, expiry) if s == OK && expiry
           yield s if block_given?
         end
+        expire(key, expiry) if expiry
       end
 
       def sort(key, options={}, &blk)
@@ -184,12 +202,12 @@ module EventMachine
       end
 
       def select(db, &blk)
-        @current_database = db
-        call_command(['select', db], &blk)
+        @db = db.to_i
+        call_command(['select', @db], &blk)
       end
 
       def auth(password, &blk)
-        @current_password = password
+        @password = password
         call_command(['auth', password], &blk)
       end
 
@@ -216,37 +234,80 @@ module EventMachine
         call_command(['quit'], &blk)
       end
 
-      def on_error(&blk)
-        @err_cb = blk
+      def exec(&blk)
+        call_command(['exec'], &blk)
+      end
+
+      # I'm not sure autocommit is a good idea.
+      # For example:
+      #   r.multi { r.set('a', 'b') { raise "kaboom" } }
+      # will commit "a" and will stop EM
+      def multi
+        call_command(['multi'])
+        if block_given?
+          begin
+            yield self
+            exec
+          rescue Exception => e
+            discard
+            raise e
+          end
+        end
       end
 
+      def mset(*args, &blk)
+        hsh = args.pop if Hash === args.last
+        if hsh
+          call_command(hsh.to_a.flatten.unshift(:mset), &blk)
+        else
+          call_command(args.unshift(:mset), &blk)
+        end
+      end
+
+      def msetnx(*args, &blk)
+        hsh = args.pop if Hash === args.last
+        if hsh
+          call_command(hsh.to_a.flatten.unshift(:msetnx), &blk)
+        else
+          call_command(args.unshift(:msetnx), &blk)
+        end
+      end
+
+      def errback(&blk)
+        @error_callback = blk
+      end
+      alias_method :on_error, :errback
+
       def method_missing(*argv, &blk)
         call_command(argv, &blk)
       end
 
-      def call_command(argv, &blk)
-        callback { raw_call_command(argv, &blk) }
+      def maybe_lock(&blk)
+        if !EM.reactor_thread?
+          EM.schedule { maybe_lock(&blk) }
+        elsif @connected
+          yield
+        else
+          callback { yield }
+        end
       end
 
-      def raw_call_command(argv, &blk)
+      def call_command(argv, &blk)
         argv = argv.dup
 
-        if MULTI_BULK_COMMANDS[argv.flatten[0].to_s]
-          # TODO improve this code
-          argvp   = argv.flatten
-          values  = argvp.pop.to_a.flatten
-          argvp   = values.unshift(argvp[0])
-          command = ["*#{argvp.size}"]
-          argvp.each do |v|
-            v = v.to_s
-            command << "$#{get_size(v)}"
-            command << v
+        argv[0] = argv[0].to_s.downcase
+        if MULTI_BULK_COMMANDS[argv[0]]
+          command = ""
+          command << "*#{argv.size}\r\n"
+          argv.each do |a|
+            a = a.to_s
+            command << "$#{get_size(a)}\r\n"
+            command << a
+            command << "\r\n"
           end
-          command = command.map {|cmd| "#{cmd}\r\n"}.join
         else
           command = ""
           bulk = nil
-          argv[0] = argv[0].to_s.downcase
           argv[0] = ALIASES[argv[0]] if ALIASES[argv[0]]
           raise "#{argv[0]} command is disabled" if DISABLED_COMMANDS[argv[0]]
           if BULK_COMMANDS[argv[0]] and argv.length > 1
@@ -257,9 +318,11 @@ module EventMachine
           command << "#{bulk}\r\n" if bulk
         end
 
-        puts "*** sending: #{command}" if $debug
-        @redis_callbacks << [REPLY_PROCESSOR[argv[0]], blk]
-        send_data command
+        @logger.debug { "*** sending: #{command}" } if @logger
+        maybe_lock do
+          @redis_callbacks << [REPLY_PROCESSOR[argv[0]], blk]
+          send_data command
+        end
       end
 
       ##
@@ -278,24 +341,58 @@ module EventMachine
       # em hooks
       #########################
 
-      def self.connect(host = 'localhost', port = 6379 )
-        puts "*** connecting" if $debug
-        EM.connect host, port, self, host, port
+      def self.connect(*args)
+        case args.length
+        when 0
+          options = {}
+        when 1
+          arg = args.shift
+          case arg
+          when Hash then options = arg
+          when String then options = {:host => arg}
+          else raise ArgumentError, 'first argument must be Hash or String'
+          end
+        when 2
+          options = {:host => args[0], :port => args[1]}
+        else
+          raise ArgumentError, "wrong number of arguments (#{args.length} for 1)"
+        end
+        options[:host] ||= '127.0.0.1'
+        options[:port]   = (options[:port] || 6379).to_i
+        EM.connect options[:host], options[:port], self, options
+      end
+
+      def initialize(options = {})
+        @host           = options[:host]
+        @port           = options[:port]
+        @db             = (options[:db] || 0).to_i
+        @password       = options[:password]
+        @logger         = options[:logger]
+        @error_callback = lambda do |code|
+          err = RedisError.new
+          err.code = code
+          raise err, "Redis server returned error code: #{code}"
+        end
+
+        # These commands should be first
+        auth_and_select_db
       end
 
-      def initialize(host, port = 6379 )
-        puts "*** initializing" if $debug
-        @host, @port = host, port
+      def auth_and_select_db
+        call_command(["auth", @password]) if @password
+        call_command(["select", @db]) unless @db == 0
       end
+      private :auth_and_select_db
 
       def connection_completed
-        puts "*** connection_complete!" if $debug
+        @logger.debug { "Connected to #{@host}:#{@port}" } if @logger
+
         @redis_callbacks = []
-        @values = []
-        @multibulk_n = 0
+        @previous_multibulks = []
+        @multibulk_n     = false
+        @reconnecting    = false
+        @connected       = true
 
-        @reconnecting = false
-        @connected = true
         succeed
       end
 
@@ -303,7 +400,7 @@ module EventMachine
       #         stack overflows when there is too much data.
       # include EM::P::LineText2
       def receive_data(data)
-        (@buffer||='') << data
+        (@buffer ||= '') << data
         while index = @buffer.index(DELIM)
           begin
             line = @buffer.slice!(0, index+2)
@@ -316,7 +413,7 @@ module EventMachine
       end
 
       def process_cmd(line)
-        puts "*** processing #{line}" if $debug
+        @logger.debug { "*** processing #{line}" } if @logger
         # first character of buffer will always be the response type
         reply_type = line[0, 1]
         reply_args = line.slice(1..-3) # remove type character and \r\n
@@ -325,85 +422,80 @@ module EventMachine
         #e.g. -MISSING
         when MINUS
           @redis_callbacks.shift # throw away the cb?
-          if @err_cb
-            @err_cb.call(reply_args)
-          else
-            err = RedisError.new
-            err.code = reply_args
-            raise err, "Redis server returned error code: #{err.code}"
-          end
-
+          @error_callback.call(reply_args)
         # e.g. +OK
         when PLUS
           dispatch_response(reply_args)
-
         # e.g. $3\r\nabc\r\n
         # 'bulk' is more complex because it could be part of multi-bulk
         when DOLLAR
           data_len = Integer(reply_args)
           if data_len == -1 # expect no data; return nil
-            if @multibulk_n > 0 # we're in the middle of a multibulk reply
-              @values << nil
-              if @values.size == @multibulk_n # DING, we're done
-                dispatch_response(@values)
-                @values = []
-                @multibulk_n = 0
-              end
-            else
-              dispatch_response(nil)
-            end
+            dispatch_response(nil)
           elsif @buffer.size >= data_len + 2 # buffer is full of expected data
-            if @multibulk_n > 0 # we're in the middle of a multibulk reply
-              @values << @buffer.slice!(0, data_len)
-              if @values.size == @multibulk_n # DING, we're done
-                dispatch_response(@values)
-                @values = []
-                @multibulk_n = 0
-              end
-            else # not multibulk
-              value = @buffer.slice!(0, data_len)
-              dispatch_response(value)
-            end
+            dispatch_response(@buffer.slice!(0, data_len))
             @buffer.slice!(0,2) # tossing \r\n
           else # buffer isn't full or nil
-            # FYI, ParseError puts command back on head of buffer, waits for
-            # more data complete buffer
-            raise ParserError 
+            # TODO: don't control execution with exceptions
+            raise ParserError
           end
-
         #e.g. :8
         when COLON
           dispatch_response(Integer(reply_args))
-
         #e.g. *2\r\n$1\r\na\r\n$1\r\nb\r\n 
         when ASTERISK
-          @multibulk_n = Integer(reply_args)
-          dispatch_response(nil) if @multibulk_n == -1
-
+          multibulk_count = Integer(reply_args)
+          if multibulk_count == -1 || multibulk_count == 0
+            dispatch_response([])
+          else
+            if @multibulk_n
+              @previous_multibulks << [@multibulk_n, @multibulk_values]
+            end
+            @multibulk_n = multibulk_count
+            @multibulk_values = []
+          end
         # Whu?
         else
+          # TODO: get rid of this exception
           raise ProtocolError, "reply type not recognized: #{line.strip}"
         end
       end
 
       def dispatch_response(value)
+        if @multibulk_n
+          @multibulk_values << value
+          @multibulk_n -= 1
+
+          if @multibulk_n == 0
+            value = @multibulk_values
+            @multibulk_n,@multibulk_values = @previous_multibulks.pop
+            if @multibulk_n
+              dispatch_response(value)
+              return
+            end
+          else
+            return
+          end
+        end
+
         processor, blk = @redis_callbacks.shift
         value = processor.call(value) if processor
         blk.call(value) if blk
       end
 
       def unbind
-        puts "*** unbinding" if $debug
-        if @connected or @reconnecting
+        @logger.debug { "Disconnected" }  if @logger
+        if @connected || @reconnecting
           EM.add_timer(1) do
+            @logger.debug { "Reconnecting to #{@host}:#{@port}" }  if @logger
             reconnect @host, @port
-            auth @current_password if @current_password
-            select @current_database if @current_database
+            auth_and_select_db
           end
           @connected = false
           @reconnecting = true
           @deferred_status = nil
         else
+          # TODO: get rid of this exception
           raise 'Unable to connect to redis server'
         end
       end