em-hiredis 0.0.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in em-hiredis.gemspec
+gemspec

data/README.md

@@ -0,0 +1,61 @@
+Getting started
+===============
+
+Connect to redis
+
+    redis_client = EM::Hiredis.connect
+
+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_client.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::Client.connect
+    subscriber = EM::Hiredis::Client.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]
+      }
+    }

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/em-hiredis.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "em-hiredis/version"
+
+Gem::Specification.new do |s|
+  s.name        = "em-hiredis"
+  s.version     = EM::Hiredis::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Martyn Loughran"]
+  s.email       = ["me@mloughran.com"]
+  s.homepage    = "http://github.com/mloughran/em-hiredis"
+  s.summary     = %q{Eventmachine redis client}
+  s.description = %q{Eventmachine redis client using hiredis native parser}
+
+  s.add_dependency 'hiredis', '~> 0.2.0'
+
+  s.rubyforge_project = "em-hiredis"
+
+  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/lib/em-hiredis/client.rb

@@ -0,0 +1,131 @@
+module EM::Hiredis
+  class Client
+    PUBSUB_MESSAGES = %w{message pmessage}.freeze
+
+    include EM::Hiredis::EventEmitter
+    include EM::Deferrable
+
+    def self.connect(host = 'localhost', port = 6379)
+      new(host, port)
+    end
+
+    def initialize(host, port)
+      @host, @port = host, port
+      @subs, @psubs = [], []
+      @defs = []
+      @connection = EM.connect(host, port, Connection, host, port)
+
+      @connection.on(:closed) {
+        if @connected
+          @defs.each { |d| d.fail("Redis disconnected") }
+          @defs = []
+          @deferred_status = nil
+          @connected = false
+          @reconnecting = true
+          reconnect
+        else
+          EM.add_timer(1) { reconnect }
+        end
+      }
+
+      @connection.on(:connected) {
+        @connected = true
+        select(@db) if @db
+        @subs.each { |s| method_missing(:subscribe, s) }
+        @psubs.each { |s| method_missing(:psubscribe, s) }
+        succeed
+
+        if @reconnecting
+          @reconnecting = false
+          emit(:reconnected)
+        end
+      }
+
+      @connection.on(:message) { |reply|
+        if RuntimeError === reply
+          raise "Replies out of sync: #{reply.inspect}" if @defs.empty?
+          deferred = @defs.shift
+          deferred.fail(reply) if deferred
+        else
+          if reply && PUBSUB_MESSAGES.include?(reply[0]) # reply can be nil
+            kind, subscription, d1, d2 = *reply
+
+            case kind.to_sym
+            when :message
+              emit(:message, subscription, d1)
+            when :pmessage
+              emit(:pmessage, subscription, d1, d2)
+            end
+          else
+            raise "Replies out of sync: #{reply.inspect}" if @defs.empty?
+            deferred = @defs.shift
+            deferred.succeed(reply) if deferred
+          end
+        end
+      }
+
+      @connected = false
+      @reconnecting = false
+    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 subscribe(channel)
+      @subs << channel
+      method_missing(:subscribe, channel)
+    end
+
+    def unsubscribe(channel)
+      @subs.delete(channel)
+      method_missing(:unsubscribe, channel)
+    end
+
+    def psubscribe(channel)
+      @psubs << channel
+      method_missing(:psubscribe, channel)
+    end
+
+    def punsubscribe(channel)
+      @psubs.delete(channel)
+      method_missing(:punsubscribe, channel)
+    end
+
+    def select(db)
+      @db = db
+      method_missing(:select, db)
+    end
+
+    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)
+      else
+        callback {
+          @connection.send_command(sym, *args)
+          @defs.push(deferred)
+        }
+      end
+
+      return deferred
+    end
+
+    private
+
+    def reconnect
+      EM::Hiredis.logger.debug("Trying to reconnect to Redis")
+      @connection.reconnect @host, @port
+    end
+  end
+end

data/lib/em-hiredis/connection.rb

@@ -0,0 +1,61 @@
+require 'hiredis/reader'
+
+module EM::Hiredis
+  class Connection < EM::Connection
+    include EM::Hiredis::EventEmitter
+
+    def initialize(host, port)
+      super
+      @host, @port = host, port
+    end
+
+    def connection_completed
+      EM::Hiredis.logger.info("Connected to Redis")
+      @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.info("Disconnected from Redis")
+      emit(:closed)
+    end
+
+    def send_command(sym, *args)
+      send_data(command(sym, *args))
+    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 EM::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/version.rb

@@ -0,0 +1,5 @@
+module EM
+  module Hiredis
+    VERSION = "0.0.1"
+  end
+end

data/lib/em-hiredis.rb

@@ -0,0 +1,22 @@
+require 'eventmachine'
+
+module EM
+  module Hiredis
+    class << self
+      attr_writer :logger
+
+      def logger
+        @logger ||= begin
+          require 'logger'
+          log = Logger.new(STDOUT)
+          log.level = Logger::WARN
+          log
+        end
+      end
+    end
+  end
+end
+
+require 'em-hiredis/event_emitter'
+require 'em-hiredis/connection'
+require 'em-hiredis/client'

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: em-hiredis
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Martyn Loughran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-11 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hiredis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id001
+description: Eventmachine redis client using hiredis native parser
+email: 
+- me@mloughran.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- em-hiredis.gemspec
+- lib/em-hiredis.rb
+- lib/em-hiredis/client.rb
+- lib/em-hiredis/connection.rb
+- lib/em-hiredis/event_emitter.rb
+- lib/em-hiredis/version.rb
+has_rdoc: true
+homepage: http://github.com/mloughran/em-hiredis
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: em-hiredis
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: Eventmachine redis client
+test_files: []
+