em-hiredis 0.0.1 → 0.1.0

data/.gitignore

@@ -3,3 +3,4 @@
 Gemfile.lock
 pkg/*
 .DS_Store
+*.swp

data/.rspec

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

data/Gemfile

@@ -1,4 +1,6 @@
 source "http://rubygems.org"
 
-# Specify your gem's dependencies in em-hiredis.gemspec
-gemspec
+gem "em-spec", :git => "git://github.com/bcg/em-spec.git"
+gem "eventmachine"
+gem "hiredis"
+gem "rspec"

data/README.md

@@ -1,13 +1,18 @@
 Getting started
 ===============
 
-Connect to redis
+Connect to redis:
 
-    redis_client = EM::Hiredis.connect
+    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_client.callback { puts "Redis now connected" }
+    redis.callback { puts "Redis now connected" }
 
 All redis commands are available without any remapping of names
 
@@ -40,8 +45,8 @@ 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
+    redis = EM::Hiredis.connect
+    subscriber = EM::Hiredis.connect
 
     subscriber.subscribe('bar.0')
     subscriber.psubscribe('bar.*')
@@ -59,3 +64,21 @@ This example should explain things. Once a redis connection is in a pubsub state
         p [:publisherror, e]
       }
     }
+
+Hacking
+-------
+
+Hacking on em-hiredis is pretty simple, make sure you have Bundler installed:
+
+    gem install bundler
+    bundle
+
+To run all the tests:
+
+    rake
+
+To run an individual test:
+
+    bundle exec rspec spec/redis_commands_spec.rb
+
+Much thanks to the em-redis gem for getting this gem bootstrapped with some tests.

data/Rakefile

@@ -1,2 +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/em-hiredis.gemspec

@@ -4,7 +4,7 @@ require "em-hiredis/version"
 
 Gem::Specification.new do |s|
   s.name        = "em-hiredis"
-  s.version     = EM::Hiredis::VERSION
+  s.version     = EventMachine::Hiredis::VERSION
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Martyn Loughran"]
   s.email       = ["me@mloughran.com"]
@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.summary     = %q{Eventmachine redis client}
   s.description = %q{Eventmachine redis client using hiredis native parser}
 
-  s.add_dependency 'hiredis', '~> 0.2.0'
+  s.add_dependency 'hiredis', '~> 0.3.0'
 
   s.rubyforge_project = "em-hiredis"
 

data/lib/em-hiredis.rb

@@ -1,17 +1,29 @@
 require 'eventmachine'
+require 'uri'
 
-module EM
+module EventMachine
   module Hiredis
-    class << self
-      attr_writer :logger
+    def self.setup(uri = nil)
+      url = URI(uri || ENV["REDIS_URL"] || "redis://127.0.0.1:6379/0")
+      Client.new(url.host, url.port, url.password, url.path[1..-1])
+    end
+
+    def self.connect(uri = nil)
+      client = setup(uri)
+      client.connect
+      client
+    end
+
+    def self.logger=(logger)
+      @@logger = logger
+    end
 
-      def logger
-        @logger ||= begin
-          require 'logger'
-          log = Logger.new(STDOUT)
-          log.level = Logger::WARN
-          log
-        end
+    def self.logger
+      @@logger ||= begin
+        require 'logger'
+        log = Logger.new(STDOUT)
+        log.level = Logger::WARN
+        log
       end
     end
   end

data/lib/em-hiredis/client.rb

@@ -1,21 +1,25 @@
-module EM::Hiredis
+module EventMachine::Hiredis
   class Client
     PUBSUB_MESSAGES = %w{message pmessage}.freeze
 
-    include EM::Hiredis::EventEmitter
+    include EventMachine::Hiredis::EventEmitter
     include EM::Deferrable
 
+    attr_reader :host, :port, :password, :db
+
     def self.connect(host = 'localhost', port = 6379)
-      new(host, port)
+      new(host, port).connect
+    end
+
+    def initialize(host, port, password = nil, db = nil)
+      @host, @port, @password, @db = host, port, password, db
+      @subs, @psubs, @defs = [], [], []
     end
 
-    def initialize(host, port)
-      @host, @port = host, port
-      @subs, @psubs = [], []
-      @defs = []
-      @connection = EM.connect(host, port, Connection, host, port)
+    def connect
+      @connection = EM.connect(@host, @port, Connection, @host, @port)
 
-      @connection.on(:closed) {
+      @connection.on(:closed) do
         if @connected
           @defs.each { |d| d.fail("Redis disconnected") }
           @defs = []
@@ -26,11 +30,14 @@ module EM::Hiredis
         else
           EM.add_timer(1) { reconnect }
         end
-      }
+      end
 
-      @connection.on(:connected) {
+      @connection.on(:connected) do
         @connected = true
+
         select(@db) if @db
+        auth(@password) if @password
+
         @subs.each { |s| method_missing(:subscribe, s) }
         @psubs.each { |s| method_missing(:psubscribe, s) }
         succeed
@@ -39,9 +46,9 @@ module EM::Hiredis
           @reconnecting = false
           emit(:reconnected)
         end
-      }
+      end
 
-      @connection.on(:message) { |reply|
+      @connection.on(:message) do |reply|
         if RuntimeError === reply
           raise "Replies out of sync: #{reply.inspect}" if @defs.empty?
           deferred = @defs.shift
@@ -57,23 +64,32 @@ module EM::Hiredis
               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
+            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
 
       @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 
+    # 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
@@ -98,11 +114,35 @@ module EM::Hiredis
       method_missing(:punsubscribe, channel)
     end
 
-    def select(db)
+    def select(db, &blk)
       @db = db
-      method_missing(:select, db)
+      method_missing(:select, db, &blk)
+    end
+
+    def auth(password, &blk)
+      @password = password
+      method_missing(:auth, password, &blk)
     end
 
+    def monitor(&blk)
+      @monitoring = true
+      method_missing(:monitor, &blk)
+    end
+
+    def info(&blk)
+      hash_processor = lambda do |response|
+        info = {}
+        response.each_line do |line|
+          key, value = line.split(":", 2)
+          info[key.to_sym] = value.chomp
+        end
+        blk.call(info)
+      end
+      method_missing(:info, &hash_processor)
+    end
+
+    private
+
     def method_missing(sym, *args)
       deferred = EM::DefaultDeferrable.new
       # Shortcut for defining the callback case with just a block
@@ -112,19 +152,17 @@ module EM::Hiredis
         @connection.send_command(sym, *args)
         @defs.push(deferred)
       else
-        callback {
+        callback do
           @connection.send_command(sym, *args)
           @defs.push(deferred)
-        }
+        end
       end
 
-      return deferred
+      deferred
     end
 
-    private
-
     def reconnect
-      EM::Hiredis.logger.debug("Trying to reconnect to Redis")
+      EventMachine::Hiredis.logger.debug("Trying to reconnect to Redis")
       @connection.reconnect @host, @port
     end
   end

data/lib/em-hiredis/connection.rb

@@ -1,8 +1,8 @@
 require 'hiredis/reader'
 
-module EM::Hiredis
+module EventMachine::Hiredis
   class Connection < EM::Connection
-    include EM::Hiredis::EventEmitter
+    include EventMachine::Hiredis::EventEmitter
 
     def initialize(host, port)
       super
@@ -10,7 +10,7 @@ module EM::Hiredis
     end
 
     def connection_completed
-      EM::Hiredis.logger.info("Connected to Redis")
+      EventMachine::Hiredis.logger.info("Connected to Redis")
       @reader = ::Hiredis::Reader.new
       emit(:connected)
     end
@@ -23,7 +23,7 @@ module EM::Hiredis
     end
 
     def unbind
-      EM::Hiredis.logger.info("Disconnected from Redis")
+      EventMachine::Hiredis.logger.info("Disconnected from Redis")
       emit(:closed)
     end
 

data/lib/em-hiredis/event_emitter.rb

@@ -1,4 +1,4 @@
-module EM::Hiredis
+module EventMachine::Hiredis
   module EventEmitter
     def on(event, &listener)
       _listeners[event] << listener

data/lib/em-hiredis/version.rb

@@ -1,5 +1,5 @@
-module EM
+module EventMachine
   module Hiredis
-    VERSION = "0.0.1"
+    VERSION = "0.1.0"
   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(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/live_redis_protocol_spec.rb

@@ -0,0 +1,512 @@
+require 'spec_helper'
+
+describe EventMachine::Hiredis, "connected to an empty db" do
+  it "sets a string value" do
+    connect do |redis|
+      redis.set("foo", "bar") do |r|
+        r.should == "OK"
+        done
+      end
+    end
+  end
+
+  it "increments the value of a string" do
+    connect do |redis|
+      redis.incr "foo" do |r|
+        r.should == 1
+        redis.incr "foo" do |r|
+          r.should == 2
+          done
+        end
+      end
+    end
+  end
+
+  it "increments the value of a string by an amount" do
+    connect do |redis|
+      redis.incrby "foo", 10 do |r|
+        r.should == 10
+        done
+      end
+    end
+  end
+
+  it "decrements the value of a string" do
+    connect do |redis|
+      redis.incr "foo" do |r|
+        r.should == 1
+        redis.decr "foo" do |r|
+          r.should == 0
+          done
+        end
+      end
+    end
+  end
+
+  it "decrement the value of a string by an amount" do
+    connect do |redis|
+      redis.incrby "foo", 20 do |r|
+        r.should == 20
+        redis.decrby "foo", 10 do |r|
+          r.should == 10
+          done
+        end
+      end
+    end
+  end
+
+  it "can 'lpush' to a nonexistent list" do
+    connect do |redis|
+      redis.lpush("foo", "bar") do |r|
+        r.should == 1
+        done
+      end
+    end
+  end
+
+  it "can 'rpush' to a nonexistent list" do
+    connect do |redis|
+      redis.rpush("foo", "bar") do |r|
+        r.should == 1
+        done
+      end
+    end
+  end
+
+
+  it "gets the size of the database" do
+    connect do |redis|
+      redis.dbsize do |r|
+        r.should == 0
+        done
+      end
+    end
+  end
+
+  it "adds a member to a nonexistent set" do
+    connect do |redis|
+      redis.sadd("set_foo", "bar") do |r|
+        r.should == 1
+        done
+      end
+    end
+  end
+
+  it "reads info about the db" do
+    connect do |redis|
+      redis.info do |info|
+        info[:redis_version].should_not be_nil
+        done
+      end
+    end
+  end
+
+  it "can save the db" do
+    connect do |redis|
+      redis.save do |r|
+        r.should == "OK"
+        done
+      end
+    end
+  end
+
+  it "can save the db in the background" do
+    connect do |redis|
+      redis.bgsave do |r|
+        r.should == "Background saving started"
+        done
+      end
+    end
+  end
+end
+
+describe EventMachine::Hiredis, "connected to a db containing some simple string-valued keys" do
+  def set(&blk)
+    connect do |redis|
+      redis.flushdb
+      redis.set "a", "b"
+      redis.set "x", "y"
+      blk.call(redis)
+    end
+  end
+
+  it "fetches the values of multiple keys" do
+    set do |redis|
+      redis.mget "a", "x" do |r|
+        r.should == ["b", "y"]
+        done
+      end
+    end
+  end
+
+  it "fetches all the keys" do
+    set do |redis|
+      redis.keys "*" do |r|
+        r.sort.should == ["a", "x"]
+        done
+      end
+    end
+  end
+
+  it "sets a value if a key doesn't exist" do
+    set do |redis|
+      redis.setnx "a", "foo" do |r|
+        r.should == 0
+        redis.setnx "zzz", "foo" do |r|
+          r.should == 1
+          done
+        end
+      end
+    end
+  end
+
+  it "tests for the existence of a key" do
+    set do |redis|
+      redis.exists "a" do |r|
+        r.should == 1
+        redis.exists "zzz" do |r|
+          r.should == 0
+          done
+        end
+      end
+    end
+  end
+
+  it "deletes a key" do
+    set do |redis|
+      redis.del "a" do |r|
+        r.should == 1
+        redis.exists "a" do |r|
+          r.should == 0
+          redis.del "a" do |r|
+            r.should == 0
+            done
+          end
+        end
+      end
+    end
+  end
+
+  it "detects the type of a key, existing or not" do
+    set do |redis|
+      redis.type "a" do |r|
+        r.should == "string"
+        redis.type "zzz" do |r|
+          r.should == "none"
+          done
+        end
+      end
+    end
+  end
+
+  it "renames a key" do
+    set do |redis|
+      redis.rename "a", "x" do |r|
+        redis.get "x" do |r|
+          r.should == "b"
+          done
+        end
+      end
+    end
+  end
+
+  it "renames a key unless it exists" do
+    set do |redis|
+      redis.renamenx "a", "x" do |r|
+        r.should == 0
+        redis.renamenx "a", "zzz" do |r|
+          r.should == 1
+          redis.get "zzz" do |r|
+            r.should == "b"
+            done
+          end
+        end
+      end
+    end
+  end
+end
+
+describe EventMachine::Hiredis, "connected to a db containing a list" do
+  def set(&blk)
+    connect do |redis|
+      redis.flushdb
+      redis.lpush "foo", "c"
+      redis.lpush "foo", "b"
+      redis.lpush "foo", "a"
+      blk.call(redis)
+    end
+  end
+
+  it "sets a list member and 'lindex' to retrieve it" do
+    set do |redis|
+      redis.lset("foo",  1, "bar") do |r|
+        redis.lindex("foo", 1) do |r|
+          r.should == "bar"
+          done
+        end
+      end
+    end
+  end
+
+  it "pushes onto tail of the list" do
+    set do |redis|
+      redis.rpush "foo", "d" do |r|
+        r.should == 4
+        redis.rpop "foo" do |r|
+          r.should == "d"
+          done
+        end
+      end
+    end
+  end
+
+  it "pushes onto the head of the list" do
+    set do |redis|
+      redis.lpush "foo", "d" do |r|
+        r.should == 4
+        redis.lpop "foo" do |r|
+          r.should == "d"
+          done
+        end
+      end
+    end
+  end
+
+  it "pops off the tail of the list" do
+    set do |redis|
+      redis.rpop("foo") do |r|
+        r.should == "c"
+        done
+      end
+    end
+  end
+
+  it "pops off the tail of the list" do
+    set do |redis|
+      redis.lpop("foo") do |r|
+        r.should == "a"
+        done
+      end
+    end
+  end
+
+  it "gets a range of values from a list" do
+    set do |redis|
+      redis.lrange("foo", 0, 1) do |r|
+        r.should == ["a", "b"]
+        done
+      end
+    end
+  end
+
+  it "trims a list" do
+    set do |redis|
+      redis.ltrim("foo", 0, 1) do |r|
+        r.should == "OK"
+        redis.llen("foo") do |r|
+          r.should == 2
+          done
+        end
+      end
+    end
+  end
+
+  it "removes a list element" do
+    set do |redis|
+      redis.lrem("foo", 0, "a") do |r|
+        r.should == 1
+        redis.llen("foo") do |r|
+          r.should == 2
+          done
+        end
+      end
+    end
+  end
+
+  it "detects the type of a list" do
+    set do |redis|
+      redis.type "foo" do |r|
+        r.should == "list"
+        done
+      end
+    end
+  end
+end
+
+describe EventMachine::Hiredis, "connected to a db containing two sets" do
+  def set(&blk)
+    connect do |redis|
+      redis.flushdb
+      redis.sadd "foo", "a"
+      redis.sadd "foo", "b"
+      redis.sadd "foo", "c"
+      redis.sadd "bar", "c"
+      redis.sadd "bar", "d"
+      redis.sadd "bar", "e"
+      blk.call(redis)
+    end
+  end
+
+  it "finds a set's cardinality" do
+    set do |redis|
+      redis.scard("foo") do |r|
+        r.should == 3
+        done
+      end
+    end
+  end
+
+  it "adds a new member to a set unless it is a duplicate" do
+    set do |redis|
+      redis.sadd("foo", "d") do |r|
+        r.should == 1 # success
+        redis.sadd("foo", "a") do |r|
+          r.should == 0 # failure
+          redis.scard("foo") do |r|
+            r.should == 4
+            done
+          end
+        end
+      end
+    end
+  end
+
+  it "removes a set member if it exists" do
+    set do |redis|
+      redis.srem("foo", "a") do |r|
+        r.should == 1
+        redis.srem("foo", "z") do |r|
+          r.should == 0
+          redis.scard("foo") do |r|
+            r.should == 2
+            done
+          end
+        end
+      end
+    end
+  end
+
+  it "retrieves a set's members" do
+    set do |redis|
+      redis.smembers("foo") do |r|
+        r.sort.should == ["a", "b", "c"]
+        done
+      end
+    end
+  end
+
+  it "detects set membership" do
+    set do |redis|
+      redis.sismember("foo", "a") do |r|
+        r.should == 1
+        redis.sismember("foo", "z") do |r|
+          r.should == 0
+          done
+        end
+      end
+    end
+  end
+
+  it "finds the sets' intersection" do
+    set do |redis|
+      redis.sinter("foo", "bar") do |r|
+        r.should == ["c"]
+        done
+      end
+    end
+  end
+
+  it "finds and stores the sets' intersection" do
+    set do |redis|
+      redis.sinterstore("baz", "foo", "bar") do |r|
+        r.should == 1
+        redis.smembers("baz") do |r|
+          r.should == ["c"]
+          done
+        end
+      end
+    end
+  end
+
+  it "finds the sets' union" do
+    set do |redis|
+      redis.sunion("foo", "bar") do |r|
+        r.sort.should == ["a","b","c","d","e"]
+        done
+      end
+    end
+  end
+
+  it "finds and stores the sets' union" do
+    set do |redis|
+      redis.sunionstore("baz", "foo", "bar") do |r|
+        r.should == 5
+        redis.smembers("baz") do |r|
+          r.sort.should == ["a","b","c","d","e"]
+          done
+        end
+      end
+    end
+  end
+
+  it "detects the type of a set" do
+    set do |redis|
+      redis.type "foo" do |r|
+        r.should == "set"
+        done
+      end
+    end
+  end
+end
+
+describe EventMachine::Hiredis, "connected to a db containing three linked lists" do
+  def set(&blk)
+    connect do |redis|
+      redis.flushdb
+      redis.rpush "foo", "a"
+      redis.rpush "foo", "b"
+      redis.set "a_sort", "2"
+      redis.set "b_sort", "1"
+      redis.set "a_data", "foo"
+      redis.set "b_data", "bar"
+      blk.call(redis)
+    end
+  end
+
+  it "collates a sorted set of data" do
+    set do |redis|
+      redis.sort("foo", "BY", "*_sort", "GET", "*_data") do |r|
+        r.should == ["bar", "foo"]
+        done
+      end
+    end
+  end
+
+  it "gets keys selectively" do
+    set do |redis|
+      redis.keys "a_*" do |r|
+        r.sort.should == ["a_sort", "a_data"].sort
+        done
+      end
+    end
+  end
+end
+
+describe EventMachine::Hiredis, "when reconnecting" do
+  it "select previously selected dataset" do
+    connect do |redis|
+      #simulate disconnect
+      redis.set('foo', 'a') { redis.close_connection_after_writing }
+
+      EventMachine.add_timer(2) do
+        redis.get('foo') do |r|
+          r.should == 'a'
+          redis.get('non_existing') do |r|
+            r.should == nil
+            done
+          end
+        end
+      end
+    end
+  end
+end