yapplabs-em-hiredis 0.4.0

data/lib/em-hiredis/pubsub_client.rb

@@ -0,0 +1,202 @@
+module EventMachine::Hiredis
+  class PubsubClient < BaseClient
+    PUBSUB_MESSAGES = %w{message pmessage subscribe unsubscribe psubscribe punsubscribe}.freeze
+
+    PING_CHANNEL = '__em-hiredis-ping'
+
+    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
+
+    # Pubsub connections to not support even the PING command, but it is useful,
+    # especially with read-only connections like pubsub, to be able to check that
+    # the TCP connection is still usefully alive.
+    #
+    # This is not particularly elegant, but it's probably the best we can do
+    # for now. Ping support for pubsub connections is being considerred:
+    # https://github.com/antirez/redis/issues/420
+    def ping
+      subscribe(PING_CHANNEL).callback {
+        unsubscribe(PING_CHANNEL)
+      }
+    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.4.0"
+  end
+end

data/lib/em-hiredis.rb

@@ -0,0 +1,66 @@
+require 'eventmachine'
+
+module EventMachine
+  module Hiredis
+    # All em-hiredis errors should descend from EM::Hiredis::Error
+    class Error < RuntimeError; end
+
+    # An error reply from Redis. The actual error retuned by ::Hiredis will be
+    # wrapped in the redis_error accessor.
+    class RedisError < Error
+      attr_accessor :redis_error
+    end
+
+    class << self
+      attr_accessor :reconnect_timeout
+    end
+    self.reconnect_timeout = 0.5
+
+    def self.setup(uri = nil, tls = false)
+      uri = uri || ENV["REDIS_URL"] || "redis://127.0.0.1:6379/0"
+      client = Client.new
+      client.configure(uri)
+      client
+    end
+
+    # Connects to redis and returns a client instance
+    #
+    # Will connect in preference order to the provided uri, the REDIS_URL
+    # environment variable, or localhost:6379
+    #
+    # TCP connections are supported via redis://:password@host:port/db (only
+    # host and port components are required). If rediss://... is passed, TLS
+    # is assumed.
+    #
+    # Unix socket uris are supported, e.g. unix:///tmp/redis.sock, however
+    # it's not possible to set the db or password - use initialize instead in
+    # this case
+    def self.connect(uri = nil, tls = false)
+      client = setup(uri, tls)
+      client.connect
+      client
+    end
+
+    def self.logger=(logger)
+      @@logger = logger
+    end
+
+    def self.logger
+      @@logger ||= begin
+        require 'logger'
+        log = ::Logger.new(STDOUT)
+        log.level = ::Logger::WARN
+        log
+      end
+    end
+
+    autoload :Lock, 'em-hiredis/lock'
+    autoload :PersistentLock, 'em-hiredis/persistent_lock'
+  end
+end
+
+require 'em-hiredis/event_emitter'
+require 'em-hiredis/connection'
+require 'em-hiredis/base_client'
+require 'em-hiredis/client'
+require 'em-hiredis/pubsub_client'

data/spec/base_client_spec.rb

@@ -0,0 +1,118 @@
+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::RedisError
+          e.should be_kind_of(EM::Hiredis::Error)
+          msg = "WRONGTYPE Operation against a key holding the wrong kind of value"
+          e.message.should == msg
+          # This is the wrapped error from redis:
+          e.redis_error.class.should == RuntimeError
+          e.redis_error.message.should == msg
+          done
+        }
+      }
+    end
+  end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe EventMachine::Hiredis, "connecting" do
+  let(:replies) do
+    # shove db number into PING reply since redis has no way
+    # of exposing the currently selected DB
+    replies = {
+      :select => lambda { |db| $db = db; "+OK" },
+      :ping   => lambda { "+PONG #{$db}" },
+      :auth   => lambda { |password| $auth = password; "+OK" },
+      :get    => lambda { |key| $auth == "secret" ? "$3\r\nbar" : "$-1" },
+    }
+  end
+
+  def connect_to_mock(url, &blk)
+    redis_mock(replies) do
+      connect(1, url, &blk)
+    end
+  end
+
+  it "doesn't call select by default" do
+    connect_to_mock("redis://localhost:6380/") do |redis|
+      redis.ping do |response|
+        response.should == "PONG "
+        done
+      end
+    end
+  end
+
+  it "selects the right db" do
+    connect_to_mock("redis://localhost:6380/9") do |redis|
+      redis.ping do |response|
+        response.should == "PONG 9"
+        done
+      end
+    end
+  end
+
+  it "authenticates with a password" do
+    connect_to_mock("redis://:secret@localhost:6380/9") do |redis|
+      redis.get("foo") do |response|
+        response.should == "bar"
+        done
+      end
+    end
+  end
+
+  it "rejects a bad password" do
+    connect_to_mock("redis://:failboat@localhost:6380/9") do |redis|
+      redis.get("foo") do |response|
+        response.should be_nil
+        done
+      end
+    end
+  end
+end

data/spec/inactivity_check_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'support/inprocess_redis_mock'
+
+def connect_mock(timeout = 10, url = "redis://localhost:6381", server = nil, &blk)
+  em(timeout) do
+    IRedisMock.start
+    redis = EventMachine::Hiredis.connect(url)
+    blk.call(redis)
+    IRedisMock.stop
+  end
+end
+
+describe EM::Hiredis::BaseClient do
+  it "should ping after activity timeout reached" do
+    connect_mock do |redis|
+      redis.configure_inactivity_check(2, 1)
+      EM.add_timer(4) {
+        IRedisMock.received.should include("ping")
+        done
+      }
+    end
+  end
+
+  it "should not ping before activity timeout reached" do
+    connect_mock do |redis|
+      redis.configure_inactivity_check(3, 1)
+      EM.add_timer(2) {
+        IRedisMock.received.should_not include("ping")
+        done
+      }
+    end
+  end
+
+  it "should ping after timeout reached even though command has been sent (no response)" do
+    connect_mock do |redis|
+      redis.configure_inactivity_check(2, 1)
+      IRedisMock.pause # no responses from now on
+
+      EM.add_timer(1.5) {
+        redis.get "test"
+      }
+
+      EM.add_timer(4) {
+        IRedisMock.received.should include("ping")
+        done
+      }
+    end
+  end
+
+  it "should trigger a reconnect when there's no response to ping" do
+    connect_mock do |redis|
+      redis.configure_inactivity_check(2, 1)
+      IRedisMock.pause # no responses from now on
+
+      EM.add_timer(1.5) {
+        redis.get "test"
+      }
+
+      EM.add_timer(5) {
+        IRedisMock.received.should include("disconnect")
+        done
+      }
+    end
+  end
+
+end