cs-em-hiredis 0.1.2

data/lib/em-hiredis/client.rb

@@ -0,0 +1,51 @@
+module EventMachine::Hiredis
+  class Client < BaseClient
+    def self.connect(host = 'localhost', port = 6379)
+      new(host, port).connect
+    end
+
+    def monitor(&blk)
+      @monitoring = true
+      method_missing(:monitor, &blk)
+    end
+
+    def info
+      df = method_missing(:info)
+      df.callback { |response|
+        info = {}
+        response.each_line do |line|
+          key, value = line.split(":", 2)
+          info[key.to_sym] = value.chomp
+        end
+        df.succeed(info)
+      }
+      df.callback { |info| yield info } if block_given?
+      df
+    end
+
+    # Gives access to a richer interface for pubsub subscriptions on a
+    # separate redis connection
+    #
+    def pubsub
+      @pubsub ||= begin
+        PubsubClient.new(@host, @port, @password, @db).connect
+      end
+    end
+
+    def subscribe(*channels)
+      raise "Use pubsub client"
+    end
+
+    def unsubscribe(*channels)
+      raise "Use pubsub client"
+    end
+
+    def psubscribe(channel)
+      raise "Use pubsub client"
+    end
+
+    def punsubscribe(channel)
+      raise "Use pubsub client"
+    end
+  end
+end

data/lib/em-hiredis/connection.rb

@@ -0,0 +1,70 @@
+require 'hiredis/reader'
+
+module EventMachine::Hiredis
+  class Connection < EM::Connection
+    include EventMachine::Hiredis::EventEmitter
+
+    def initialize(host, port)
+      super
+      @host, @port = host, port
+    end
+
+    def reconnect(host, port)
+      super
+      @host, @port = host, port
+    end
+
+    def connection_completed
+      EM::Hiredis.logger.debug("#{to_s}: connection open")
+      @reader = ::Hiredis::Reader.new
+      emit(:connected)
+    end
+
+    def receive_data(data)
+      @reader.feed(data)
+      until (reply = @reader.gets) == false
+        emit(:message, reply)
+      end
+    end
+
+    def unbind
+      EM::Hiredis.logger.debug("#{to_s}: connection unbound")
+      emit(:closed)
+    end
+
+    def send_command(sym, *args)
+      send_data(command(sym, *args))
+    end
+
+    def to_s
+      "Redis connection #{@host}:#{@port}"
+    end
+
+    protected
+
+    COMMAND_DELIMITER = "\r\n"
+
+    def command(*args)
+      command = []
+      command << "*#{args.size}"
+
+      args.each do |arg|
+        arg = arg.to_s
+        command << "$#{string_size arg}"
+        command << arg
+      end
+
+      command.join(COMMAND_DELIMITER) + COMMAND_DELIMITER
+    end
+
+    if "".respond_to?(:bytesize)
+      def string_size(string)
+        string.to_s.bytesize
+      end
+    else
+      def string_size(string)
+        string.to_s.size
+      end
+    end
+  end
+end

data/lib/em-hiredis/event_emitter.rb

@@ -0,0 +1,29 @@
+module EventMachine::Hiredis
+  module EventEmitter
+    def on(event, &listener)
+      _listeners[event] << listener
+    end
+
+    def emit(event, *args)
+      _listeners[event].each { |l| l.call(*args) }
+    end
+
+    def remove_listener(event, &listener)
+      _listeners[event].delete(listener)
+    end
+
+    def remove_all_listeners(event)
+      _listeners.delete(event)
+    end
+
+    def listeners(event)
+      _listeners[event]
+    end
+
+    private
+
+    def _listeners
+      @_listeners ||= Hash.new { |h,k| h[k] = [] }
+    end
+  end
+end

data/lib/em-hiredis/lock.rb

@@ -0,0 +1,89 @@
+module EM::Hiredis
+  # Distributed lock built on redis
+  class Lock
+    def onexpire(&blk); @onexpire = blk; end
+
+    def initialize(redis, key, timeout)
+      @redis, @key, @timeout = redis, key, timeout
+      @locked = false
+      @expiry = nil
+    end
+
+    # Acquire the lock
+    #
+    # It is ok to call acquire again before the lock expires, which will attempt to extend the existing lock.
+    #
+    # Returns a deferrable which either succeeds if the lock can be acquired, or fails if it cannot. In both cases the expiry timestamp is returned (for the new lock or for the expired one respectively)
+    def acquire
+      df = EM::DefaultDeferrable.new
+      expiry = new_expiry
+      @redis.setnx(@key, expiry) { |setnx|
+        if setnx == 1
+          lock_acquired(expiry)
+          df.succeed(expiry)
+        else
+          attempt_to_acquire_existing_lock(df)
+        end
+      }
+      return df
+    end
+
+    # Release the lock
+    def unlock
+      EM.cancel_timer(@expire_timer) if @expire_timer
+      
+      if @locked && Time.now.to_i < @expiry
+        EM::Hiredis.logger.debug "Lock: released #{@key}"
+        @redis.del(@key)
+      else
+        EM::Hiredis.logger.debug "Lock: could not release #{@key}"
+      end
+    end
+
+    # This should not be used in normal operation - force clear
+    def clear
+      @redis.del(@key)
+    end
+
+    private
+
+    def attempt_to_acquire_existing_lock(df)
+      @redis.get(@key) { |expiry_1|
+        expiry_1 = expiry_1.to_i
+        if expiry_1 == @expiry || expiry_1 < Time.now.to_i
+          # Either the lock was ours or the lock has already expired
+          expiry = new_expiry
+          @redis.getset(@key, expiry) { |expiry_2|
+            expiry_2 = expiry_2.to_i
+            if expiry_2 == @expiry || expiry_2 < Time.now.to_i
+              lock_acquired(expiry)
+              df.succeed(expiry)
+            else
+              # Another client got there first
+              EM::Hiredis.logger.debug "Lock: failed to acquire #{@key}"
+              df.fail(expiry_2)
+            end
+          }
+        else
+          EM::Hiredis.logger.debug "Lock: failed to acquire #{@key}"
+          df.fail(expiry_1)
+        end
+      }
+    end
+
+    def new_expiry
+      Time.now.to_i + @timeout + 1
+    end
+
+    def lock_acquired(expiry)
+      EM::Hiredis.logger.debug "Lock: acquired #{@key}"
+      @locked = true
+      @expiry = expiry
+      EM.cancel_timer(@expire_timer) if @expire_timer
+      @expire_timer = EM.add_timer(@timeout) {
+        EM::Hiredis.logger.debug "Lock: #{@key} will expire in 1s"
+        @onexpire.call if @onexpire
+      }
+    end
+  end
+end

data/lib/em-hiredis/pubsub_client.rb

@@ -0,0 +1,187 @@
+module EventMachine::Hiredis
+  class PubsubClient < BaseClient
+    PUBSUB_MESSAGES = %w{message pmessage subscribe unsubscribe psubscribe punsubscribe}.freeze
+
+    def initialize(host='localhost', port='6379', password=nil, db=nil)
+      @subs, @psubs = [], []
+      @pubsub_defs = Hash.new { |h,k| h[k] = [] }
+      super
+    end
+
+    def connect
+      @sub_callbacks = Hash.new { |h, k| h[k] = [] }
+      @psub_callbacks = Hash.new { |h, k| h[k] = [] }
+      
+      # Resubsubscribe to channels on reconnect
+      on(:reconnected) {
+        raw_send_command(:subscribe, *@subs) if @subs.any?
+        raw_send_command(:psubscribe, *@psubs) if @psubs.any?
+      }
+      
+      super
+    end
+    
+    # Subscribe to a pubsub channel
+    # 
+    # If an optional proc / block is provided then it will be called when a
+    # message is received on this channel
+    # 
+    # @return [Deferrable] Redis subscribe call
+    # 
+    def subscribe(channel, proc = nil, &block)
+      if cb = proc || block
+        @sub_callbacks[channel] << cb
+      end
+      @subs << channel
+      raw_send_command(:subscribe, channel)
+      return pubsub_deferrable(channel)
+    end
+    
+    # Unsubscribe all callbacks for a given channel
+    #
+    # @return [Deferrable] Redis unsubscribe call
+    #
+    def unsubscribe(channel)
+      @sub_callbacks.delete(channel)
+      @subs.delete(channel)
+      raw_send_command(:unsubscribe, channel)
+      return pubsub_deferrable(channel)
+    end
+
+    # Unsubscribe a given callback from a channel. Will unsubscribe from redis
+    # if there are no remaining subscriptions on this channel
+    #
+    # @return [Deferrable] Succeeds when the unsubscribe has completed or
+    #   fails if callback could not be found. Note that success may happen
+    #   immediately in the case that there are other callbacks for the same
+    #   channel (and therefore no unsubscription from redis is necessary)
+    #
+    def unsubscribe_proc(channel, proc)
+      df = EM::DefaultDeferrable.new
+      if @sub_callbacks[channel].delete(proc)
+        if @sub_callbacks[channel].any?
+          # Succeed deferrable immediately - no need to unsubscribe
+          df.succeed
+        else
+          unsubscribe(channel).callback { |_|
+            df.succeed
+          }
+        end
+      else
+        df.fail
+      end
+      return df
+    end
+
+    # Pattern subscribe to a pubsub channel
+    #
+    # If an optional proc / block is provided then it will be called (with the
+    # channel name and message) when a message is received on a matching
+    # channel
+    #
+    # @return [Deferrable] Redis psubscribe call
+    #
+    def psubscribe(pattern, proc = nil, &block)
+      if cb = proc || block
+        @psub_callbacks[pattern] << cb
+      end
+      @psubs << pattern
+      raw_send_command(:psubscribe, pattern)
+      return pubsub_deferrable(pattern)
+    end
+
+    # Pattern unsubscribe all callbacks for a given pattern
+    #
+    # @return [Deferrable] Redis punsubscribe call
+    #
+    def punsubscribe(pattern)
+      @psub_callbacks.delete(pattern)
+      @psubs.delete(pattern)
+      raw_send_command(:punsubscribe, pattern)
+      return pubsub_deferrable(pattern)
+    end
+
+    # Unsubscribe a given callback from a pattern. Will unsubscribe from redis
+    # if there are no remaining subscriptions on this pattern
+    #
+    # @return [Deferrable] Succeeds when the punsubscribe has completed or
+    #   fails if callback could not be found. Note that success may happen
+    #   immediately in the case that there are other callbacks for the same
+    #   pattern (and therefore no punsubscription from redis is necessary)
+    #
+    def punsubscribe_proc(pattern, proc)
+      df = EM::DefaultDeferrable.new
+      if @psub_callbacks[pattern].delete(proc)
+        if @psub_callbacks[pattern].any?
+          # Succeed deferrable immediately - no need to punsubscribe
+          df.succeed
+        else
+          punsubscribe(pattern).callback { |_|
+            df.succeed
+          }
+        end
+      else
+        df.fail
+      end
+      return df
+    end
+    
+    private
+    
+    # Send a command to redis without adding a deferrable for it. This is
+    # useful for commands for which replies work or need to be treated
+    # differently
+    def raw_send_command(sym, *args)
+      if @connected
+        @connection.send_command(sym, *args)
+      else
+        callback do
+          @connection.send_command(sym, *args)
+        end
+      end
+      return nil
+    end
+
+    def pubsub_deferrable(channel)
+      df = EM::DefaultDeferrable.new
+      @pubsub_defs[channel].push(df)
+      df
+    end
+
+    def handle_reply(reply)
+      if reply && PUBSUB_MESSAGES.include?(reply[0]) # reply can be nil
+        # Note: pmessage is the only message with 4 arguments
+        kind, subscription, d1, d2 = *reply
+
+        case kind.to_sym
+        when :message
+          if @sub_callbacks.has_key?(subscription)
+            @sub_callbacks[subscription].each { |cb| cb.call(d1) }
+          end
+          # Arguments are channel, message payload
+          emit(:message, subscription, d1)
+        when :pmessage
+          if @psub_callbacks.has_key?(subscription)
+            @psub_callbacks[subscription].each { |cb| cb.call(d1, d2) }
+          end
+          # Arguments are original pattern, channel, message payload
+          emit(:pmessage, subscription, d1, d2)
+        else
+          if @pubsub_defs[subscription].any?
+            df = @pubsub_defs[subscription].shift
+            df.succeed(d1)
+            # Cleanup empty arrays
+            if @pubsub_defs[subscription].empty?
+              @pubsub_defs.delete(subscription)
+            end
+          end
+
+          # Also emit the event, as an alternative to using the deferrables
+          emit(kind.to_sym, subscription, d1)
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/lib/em-hiredis/version.rb

@@ -0,0 +1,5 @@
+module EventMachine
+  module Hiredis
+    VERSION = "0.1.2"
+  end
+end

data/spec/base_client_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe EM::Hiredis::BaseClient do
+  it "should be able to connect to redis (required for all tests!)" do
+    em {
+      redis = EM::Hiredis.connect
+      redis.callback {
+        done
+      }
+      redis.errback {
+        puts "CHECK THAT THE REDIS SERVER IS RUNNING ON PORT 6379"
+        fail
+      }
+    }
+  end
+
+  it "should emit an event on reconnect failure, with the retry count" do
+    # Assumes there is no redis server on 9999
+    connect(1, "redis://localhost:9999/") do |redis|
+      expected = 1
+      redis.on(:reconnect_failed) { |count|
+        count.should == expected
+        expected += 1
+        done if expected == 3
+      }
+    end
+  end
+  
+  it "should emit disconnected when the connection closes" do
+    connect do |redis|
+      redis.on(:disconnected) {
+        done
+      }
+      redis.close_connection
+    end
+  end
+
+  it "should fail the client deferrable after 4 unsuccessful attempts" do
+    connect(1, "redis://localhost:9999/") do |redis|
+      events = []
+      redis.on(:reconnect_failed) { |count|
+        events << count
+      }
+      redis.errback { |error|
+        error.class.should == EM::Hiredis::Error
+        error.message.should == 'Could not connect after 4 attempts'
+        events.should == [1,2,3,4]
+        done
+      }
+    end
+  end
+
+  it "should fail commands immediately when in failed state" do
+    connect(1, "redis://localhost:9999/") do |redis|
+      redis.fail
+      redis.get('foo').errback { |error|
+        error.class.should == EM::Hiredis::Error
+        error.message.should == 'Redis connection in failed state'
+        done
+      }
+    end
+  end
+
+  it "should fail queued commands when entering failed state" do
+    connect(1, "redis://localhost:9999/") do |redis|
+      redis.get('foo').errback { |error|
+        error.class.should == EM::Hiredis::Error
+        error.message.should == 'Redis connection in failed state'
+        done
+      }
+      redis.fail
+    end
+  end
+
+  it "should allow reconfiguring the client at runtime" do
+    connect(1, "redis://localhost:9999/") do |redis|
+      redis.on(:reconnect_failed) {
+        redis.configure("redis://localhost:6379/9")
+        redis.info {
+          done
+        }
+      }
+    end
+  end
+
+  it "should allow connection to be reconnected" do
+    connect do |redis|
+      redis.on(:reconnected) {
+        done
+      }
+      # Wait for first connection to complete
+      redis.callback {
+        redis.reconnect_connection
+      }
+    end
+  end
+
+  it "should wrap error responses returned by redis" do
+    connect do |redis|
+      redis.sadd('foo', 'bar') {
+        df = redis.get('foo')
+        df.callback {
+          fail "Should have received error response from redis"
+        }
+        df.errback { |e|
+          e.class.should == EM::Hiredis::Error
+          e.message.should == 'Error reply from redis'
+          # This is the wrapped error from redis:
+          e.redis_error.message.should == 'ERR Operation against a key holding the wrong kind of value'
+          done
+        }
+      }
+    end
+  end
+end