cs-em-hiredis 0.1.2

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store
+*.swp

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENCE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Martyn Loughran
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,85 @@
+Getting started
+===============
+
+Connect to redis:
+
+    require 'em-hiredis'
+    redis = EM::Hiredis.connect
+
+Or, connect to redis with a redis URL (for a different host, port, password, DB)
+
+    redis = EM::Hiredis.connect("redis://:secretpassword@example.com:9000/4")
+
+The client is a deferrable which succeeds when the underlying connection is established so you can bind to this. This isn't necessary however - any commands sent before the connection is established (or while reconnecting) will be sent to redis on connect.
+
+    redis.callback { puts "Redis now connected" }
+
+All redis commands are available without any remapping of names
+
+    redis.set('foo', 'bar').callback {
+      redis.get('foo').callback { |value|
+        p [:returned, value]
+      }
+    }
+
+As a shortcut, if you're only interested in binding to the success case you can simply provide a block to any command
+
+    redis.get('foo') { |value|
+      p [:returned, value]
+    }
+
+Handling failure
+----------------
+
+All commands return a deferrable. In the case that redis replies with an error (for example you called a hash operation against a set), or in the case that the redis connection is broken before the command returns, the deferrable will fail. If you care about the failure case you should bind to the errback - for example:
+
+    redis.sadd('aset', 'member').callback {
+      response_deferrable = redis.hget('aset', 'member')
+      response_deferrable.errback { |e|
+        p e # => #<RuntimeError: ERR Operation against a key holding the wrong kind of value>
+      }
+    }
+
+Pubsub
+------
+
+This example should explain things. Once a redis connection is in a pubsub state, you must make sure you only send pubsub commands.
+
+    redis = EM::Hiredis.connect
+    subscriber = EM::Hiredis.connect
+
+    subscriber.subscribe('bar.0')
+    subscriber.psubscribe('bar.*')
+
+    subscriber.on(:message) { |channel, message|
+      p [:message, channel, message]
+    }
+
+    subscriber.on(:pmessage) { |key, channel, message|
+      p [:pmessage, key, channel, message]
+    }
+
+    EM.add_periodic_timer(1) {
+      redis.publish("bar.#{rand(2)}", "hello").errback { |e|
+        p [:publisherror, e]
+      }
+    }
+
+Hacking
+-------
+
+Hacking on em-hiredis is pretty simple, make sure you have Bundler installed:
+
+    gem install bundler
+    bundle
+
+In order to run the tests you need to have a local redis server running on port 6379. Run all the tests:
+
+    # WARNING: The tests call flushdb on db 9 - this clears all keys!
+    bundle exec rake 
+
+To run an individual test:
+
+    bundle exec rspec spec/redis_commands_spec.rb
+
+Many thanks to the em-redis gem for getting this gem bootstrapped with some tests.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+end

data/cs-em-hiredis.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "em-hiredis/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cs-em-hiredis"
+  s.version     = EventMachine::Hiredis::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Martyn Loughran", "Yuri Niyazov"]
+  s.email       = ["me@mloughran.com", "yuri.niyazov@gmail.com"]
+  s.homepage    = "http://github.com/yn/em-hiredis"
+  s.summary     = %q{Eventmachine redis client}
+  s.description = %q{Eventmachine redis client using hiredis native parser}
+
+  s.add_dependency 'hiredis', '~> 0.4.0'
+
+  s.add_development_dependency 'em-spec', '~> 0.2.5'
+  s.add_development_dependency 'rspec', '~> 2.6.0'
+  s.add_development_dependency 'rake'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/examples/pubsub.rb

@@ -0,0 +1,52 @@
+require 'rubygems'
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'em-hiredis'
+
+EM.run {
+  redis = EM::Hiredis.connect
+  
+  # If you pass a block to subscribe it will be called whenever a message
+  # is received on this channel
+  redis.pubsub.subscribe('foo') { |message|
+    puts "Block received #{message}"
+  }
+  
+  # You can also pass any other object which responds to call if you wish
+  callback = Proc.new { |message|
+    "Proc received #{message}"
+  }
+  df = redis.pubsub.subscribe('foo', callback)
+  
+  # All calls return a deferrable
+  df.callback { |reply|
+    p [:subscription_succeeded, reply]
+  }
+  
+  # Passing such an object is useful if you want to unsubscribe
+  redis.pubsub.unsubscribe_proc('foo', callback)
+  
+  # Or if you want to call a method on a certain object
+  class Thing
+    def receive_message(message)
+      puts "Thing received #{message}"
+    end
+  end
+  redis.pubsub.subscribe('bar', Thing.new.method(:receive_message))
+  
+  # You can also get all the following raw events:
+  # message pmessage subscribe unsubscribe psubscribe punsubscribe
+  redis.pubsub.on(:message) { |channel, message|
+    p [:message_received, channel, message]
+  }
+  redis.pubsub.on(:unsubscribe) { |channel, remaining_subscriptions|
+    p [:unsubscribe_happened, channel, remaining_subscriptions]
+  }
+  
+  EM.add_timer(1) {
+    # You can also unsubscribe completely from a channel
+    redis.pubsub.unsubscribe('foo')
+    
+    # Publishing events
+    redis.publish('bar', 'Hello')
+  }
+}

data/lib/em-hiredis.rb

@@ -0,0 +1,49 @@
+require 'eventmachine'
+
+module EventMachine
+  module Hiredis
+    class Error < RuntimeError
+      # In the case of error responses from Redis, the RuntimeError returned
+      # by ::Hiredis will be wrapped
+      attr_accessor :redis_error
+    end
+
+    class << self
+      attr_accessor :reconnect_timeout
+    end
+    self.reconnect_timeout = 0.5
+
+    def self.setup(uri = nil)
+      uri = uri || ENV["REDIS_URL"] || "redis://127.0.0.1:6379/0"
+      client = Client.new
+      client.configure(uri)
+      client
+    end
+
+    def self.connect(uri = nil)
+      client = setup(uri)
+      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
+  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'
+require 'em-hiredis/lock'

data/lib/em-hiredis/base_client.rb

@@ -0,0 +1,199 @@
+require 'uri'
+
+module EventMachine::Hiredis
+  # Emits the following events
+  #
+  # * :connected - on successful connection or reconnection
+  # * :reconnected - on successful reconnection
+  # * :disconnected - no longer connected, when previously in connected state
+  # * :reconnect_failed(failure_number) - a reconnect attempt failed
+  #     This event is passed number of failures so far (1,2,3...)
+  # * :monitor
+  #
+  class BaseClient
+    include EventEmitter
+    include EM::Deferrable
+
+    attr_reader :host, :port, :password, :db
+
+    def initialize(host='localhost', port='6379', password=nil, db=nil)
+      @host, @port, @password, @db = host, port, password, db
+      @defs = []
+      @command_queue = []
+
+      @closing_connection = false
+      @reconnect_failed_count = 0
+      @reconnect_timer = nil
+      @failed = false
+
+      self.on(:failed) {
+        @failed = true
+        @command_queue.each do |df, _, _|
+          df.fail(Error.new("Redis connection in failed state"))
+        end
+        @command_queue = []
+      }
+    end
+
+    # Configure the redis connection to use
+    #
+    # In usual operation, the uri should be passed to initialize. This method
+    # is useful for example when failing over to a slave connection at runtime
+    #
+    def configure(uri_string)
+      uri = URI(uri_string)
+      @host = uri.host
+      @port = uri.port
+      @password = uri.password
+      path = uri.path[1..-1]
+      @db = path.empty? ? nil : path
+    end
+
+    def connect
+      @connection = EM.connect(@host, @port, Connection, @host, @port)
+
+      @connection.on(:closed) do
+        if @connected
+          @defs.each { |d| d.fail(Error.new("Redis disconnected")) }
+          @defs = []
+          @deferred_status = nil
+          @connected = false
+          unless @closing_connection
+            reconnect
+          end
+          emit(:disconnected)
+          EM::Hiredis.logger.info("#{@connection.to_s} disconnected")
+        else
+          unless @closing_connection
+            @reconnect_failed_count += 1
+            @reconnect_timer = EM.add_timer(EM::Hiredis.reconnect_timeout) {
+              @reconnect_timer = nil
+              reconnect
+            }
+            emit(:reconnect_failed, @reconnect_failed_count)
+            EM::Hiredis.logger.info("#{@connection.to_s} reconnect failed")
+
+            if @reconnect_failed_count >= 4
+              emit(:failed)
+              self.fail(Error.new("Could not connect after 4 attempts"))
+            end
+          end
+        end
+      end
+
+      @connection.on(:connected) do
+        @connected = true
+        @reconnect_failed_count = 0
+        @failed = false
+
+        select(@db) if @db
+        auth(@password) if @password
+
+        @command_queue.each do |df, command, args|
+          @connection.send_command(command, *args)
+          @defs.push(df)
+        end
+        @command_queue = []
+
+        emit(:connected)
+        EM::Hiredis.logger.info("#{@connection.to_s} connected")
+        succeed
+
+        if @reconnecting
+          @reconnecting = false
+          emit(:reconnected)
+        end
+      end
+
+      @connection.on(:message) do |reply|
+        if RuntimeError === reply
+          raise "Replies out of sync: #{reply.inspect}" if @defs.empty?
+          deferred = @defs.shift
+          error = Error.new("Error reply from redis")
+          error.redis_error = reply
+          deferred.fail(error) if deferred
+        else
+          handle_reply(reply)
+        end
+      end
+
+      @connected = false
+      @reconnecting = false
+
+      return self
+    end
+
+    # Indicates that commands have been sent to redis but a reply has not yet
+    # been received
+    #
+    # This can be useful for example to avoid stopping the
+    # eventmachine reactor while there are outstanding commands
+    #
+    def pending_commands?
+      @connected && @defs.size > 0
+    end
+
+    def connected?
+      @connected
+    end
+
+    def select(db, &blk)
+      @db = db
+      method_missing(:select, db, &blk)
+    end
+
+    def auth(password, &blk)
+      @password = password
+      method_missing(:auth, password, &blk)
+    end
+
+    def close_connection
+      EM.cancel_timer(@reconnect_timer) if @reconnect_timer
+      @closing_connection = true
+      @connection.close_connection_after_writing
+    end
+
+    def reconnect_connection
+      EM.cancel_timer(@reconnect_timer) if @reconnect_timer
+      reconnect
+    end
+
+    private
+
+    def method_missing(sym, *args)
+      deferred = EM::DefaultDeferrable.new
+      # Shortcut for defining the callback case with just a block
+      deferred.callback { |result| yield(result) } if block_given?
+
+      if @connected
+        @connection.send_command(sym, *args)
+        @defs.push(deferred)
+      elsif @failed
+        deferred.fail(Error.new("Redis connection in failed state"))
+      else
+        @command_queue << [deferred, sym, args]
+      end
+
+      deferred
+    end
+
+    def reconnect
+      @reconnecting = true
+      @connection.reconnect @host, @port
+      EM::Hiredis.logger.info("#{@connection.to_s} reconnecting")
+    end
+
+    def handle_reply(reply)
+      if @defs.empty?
+        if @monitoring
+          emit(:monitor, reply)
+        else
+          raise "Replies out of sync: #{reply.inspect}"
+        end
+      else
+        deferred = @defs.shift
+        deferred.succeed(reply) if deferred
+      end
+    end
+  end
+end