redis_ha 0.0.5 → 0.1.0

data/README.md

@@ -1,31 +1,97 @@
 RedisHA
 =======
 
-Three basic CRDTs (set, hashmap and counter) for redis. Also includes
-a ConnectionPool that allows you to run concurrent redis commands on
-multiple connections w/o using eventmachine/em-hiredis.
+A redis client that runs commands on multiple servers in parallel 
+without blocking if one of them is down.
+
+I used this to implement a highly available session store on top of
+redis; it writes and reads the data to multiple instances and merges 
+the responses after every read. This approach is negligibly slower 
+than writing to a single server since RedisHA uses asynchronous I/O 
+and is much more robust than complex server-side redis failover solutions
+(sentinel, pacemaker, etcetera).
+
+The gem includes three basic CRDTs (set, hashmap and counter).
+
+[1] _DeCandia, Hastorun et al_ (2007). [Dynamo: Amazon’s Highly Available Key-value Store](http://www.read.seas.harvard.edu/~kohler/class/cs239-w08/decandia07dynamo.pd) (SOSP 2007)
+
 
 Usage
 -----
 
-Create a RedisHA::ConnectionPool
+Create a RedisHA::ConnectionPool (connect does not block):
+
+```ruby
+pool = RedisHA::ConnectionPool.new
+pool.connect(
+  {:host => "localhost", :port => 6379},
+  {:host => "localhost", :port => 6380},
+  {:host => "localhost", :port => 6381}
+)
+```
+
+Execute a command in parallel:
+
+```ruby
+>> pool.ping
+=> ["PONG", "PONG", "PONG"]
+
+>> pool.setnx "fnord", 1
+=> [1,1,1]
+```
+
+RedisHA::Counter (INCR/DECR/SET/GET)
+
+```ruby
+>> ctr = RedisHA::Counter.new(pool, "my-counter")
+
+>> ctr.set 3
+=> true
+
+>> ctr.incr
+=> true
+
+>> ctr.get
+=> 4
+```
+
+RedisHA::HashMap (SET/GET) 
+
+```ruby
+>> map = RedisHA::HashMap.new(pool, "my-hashmap")
+
+>> map.set(:fnord => 1, :fubar => 2)
+=> true
+
+=> map.get
+=> {:fnord=>1, :fubar=>2}
+```
 
-    here be dragons
+RedisHA::Set (ADD/REM/GET)
 
+```ruby
+>> set = RedisHA::Set.new(pool, "my-set")
 
-ADD/REM/GET on a RedisHA::Set
+>> set.add(:fnord, :bar)
+=> true
 
-    here be dragons
+>> set.rem(:bar)
+=> true
 
+>> set.get
+=> [:fnord]
+```
 
-INCR/DECR/SET/GET on a RedisHA::Counter
+Timeouts
+--------
 
-    here be dragons
+here be dragons
 
 
-SET/GET on a RedisHA::HashMap
+Caveats
+--------
 
-    here be dragons
+-> delete / decrement is not safe
 
 
 

data/lib/redis_ha/connection.rb

@@ -1,92 +1,98 @@
-class RedisHA::Connection < Thread
+class RedisHA::Connection < Socket
+  attr_accessor :addr, :status, :read_buffer, :write_buffer
 
-  POLL_INTERVAL = 0.01
+  def initialize(redis, pool)
+    @write_buffer = ""
+    @read_buffer = ""
 
-  attr_accessor :status, :buffer
+    super(AF_INET, SOCK_STREAM, 0)
 
-  def initialize(redis_opts, opts = {})
-    self.abort_on_exception = true
-
-    @read_timeout = opts[:read_timeout]
-    @retry_timeout = opts[:retry_timeout]
-    @redis_opts = redis_opts
-
-    @queue = Array.new
-    @queue_lock = Mutex.new
-    @buffer = Array.new
-    @buffer_lock = Mutex.new
+    @pool = pool
+    setup(redis)
+  end
 
-    super do
-      run
-    end
+  def yield_connect
+    connect_nonblock(@__addr)
+  rescue Errno::EINPROGRESS, Errno::ECONNABORTED, Errno::EINVAL
+    nil
+  rescue Errno::ECONNREFUSED
+    finish(:fail)
   end
 
-  def next
-    @buffer_lock.synchronize do
-      @buffer.shift
+  def yield_read
+    loop do
+      @read_buffer << read_nonblock(1)[0]
     end
+  rescue Errno::EAGAIN
+    check || raise(Errno::EAGAIN)
+  rescue Errno::ENOTCONN
+    yield_connect
+  rescue Errno::ECONNREFUSED
+    finish(:fail)
   end
 
-  def <<(msg)
-    @buffer_lock.synchronize do
-      @queue << msg
-    end
+  def yield_write
+    len = write_nonblock(@write_buffer)
+    @write_buffer = @write_buffer[len..-1] || ""
+  rescue Errno::EPIPE
+    yield_connect
+  rescue Errno::ECONNREFUSED
+    finish(:fail)
   end
 
-private
+  def <<(buf)
+    @write_buffer << buf
+  end
 
-  def run
-    while job = pop
-      semaphore, *msg = job
+  def rewind
+    @read_buffer = ""
+    @write_buffer = ""
+    @ready = false
+  end
 
-      @buffer_lock.synchronize do
-        @buffer << send(*msg)
-      end
+  def wait_read?
+    return false if @ready
+    @write_buffer.size == 0
+  end
 
-      semaphore.decrement
-    end
+  def wait_write?
+    return false if @ready
+    @write_buffer.size != 0
   end
 
-  def pop
-    loop do
-      sleep(POLL_INTERVAL) while @queue.size < 1
-      @queue_lock.synchronize do
-        job = @queue.shift
-        return job if job
-      end
-    end
+  def execution_expired
+    finish(:fail)
   end
 
-  def connect
-    with_timeout_and_check do
-      @redis = Redis.new(@redis_opts)
-      @redis.ping
-    end
+  def ready?
+    @ready == true
   end
 
-  def method_missing(*msg)
-    with_timeout_and_check do
-      @redis.send(*msg)
-    end
+  def setup(redis)
+    addr = [redis.fetch(:port), redis.fetch(:host)]
+    addr[1] = (TCPSocket.gethostbyname(addr[1])[4])
+    @__addr = Socket.pack_sockaddr_in(*addr)
   end
 
-  def with_timeout_and_check(&block)
-    return nil unless up_or_retry?
-    with_timeout(&block)
+  def finish(stat)
+    @ready = true
+
+    if stat == :success
+      @down_since = nil if @status != :up
+      @status = :up
+    else
+      @status = :down
+      @down_since = Time.now.to_f
+    end
   end
 
-  def with_timeout
-    ret = Timeout::timeout(@read_timeout) do
-      yield
+  def check
+    if RedisHA::Protocol.peek?(@read_buffer)
+      @ready = true
     end
-  rescue Exception => e
-    @status = :down
-    @down_since = Time.now.to_f
-    return nil
-  else
-    @down_since = nil if @status != :up
-    @status = :up
-    return ret
+
+    finish(:success) if @ready
+    @ready
   end
 
   def up_or_retry?
@@ -94,9 +100,8 @@ private
     return true unless @down_since
 
     down_diff = Time.now.to_f - @down_since
-    return true if down_diff > @retry_timeout
+    return true if down_diff > @pool.retry_timeout
     false
   end
 
 end
-

data/lib/redis_ha/connection_pool.rb

@@ -15,54 +15,80 @@ class RedisHA::ConnectionPool
     @retry_timeout = DEFAULT_RETRY_TIMEOUT
 
     @connections = []
-    @connected = false
   end
 
   def connect(*conns)
-    @connected = true
-
     conns.each do |conn|
-      @connections << setup(conn)
+      @connections << RedisHA::Connection.new(conn, self)
+      @connections.last.yield_connect
     end
+  end
 
-    async(:connect)
+  def method_missing(*msg)
+    msg = msg.map(&:to_s)
+    req = RedisHA::Protocol.request(*msg)
+    execute(req)
   end
 
-  def ensure_connected
-    unless @connected
-      raise RedisHA::Error.new("you need to call Base.connect first")
-    end
+private
 
-    unless @connections.map(&:status).include?(:up)
-      raise RedisHA::Error.new("no servers available")
+  def execute(cmd)
+    @connections.each do |c|
+      c.rewind
+      c << cmd
     end
-  end
 
-  def method_missing(*msg)
-    ensure_connected
-    async(*msg)
-  end
+    await
 
-private
+    @connections.map do |conn|
+      res = RedisHA::Protocol.parse(conn.read_buffer)
 
-  def async(*msg)
-    @semaphore = RedisHA::Semaphore.new(@connections.size)
+      if res.is_a?(Exception)
+        @connections.each(&:rewind)
+        raise res
+      else
+        res
+      end
+    end
+  end
 
-    @connections.each do |conn|
-      conn << [@semaphore, *msg]
+  def select
+    req = [[],[],[]]
+
+    @connections.each do |c|
+      req[0] << c if c.wait_read?
+      req[1] << c if c.wait_write?
     end
 
-    @semaphore.wait
+    req << @read_timeout
+    ready = IO.select(*req)
 
-    @connections.map(&:next).tap do
-      ensure_connected
+    unless ready
+      req[0].each(&:execution_expired)
+      req[1].each(&:execution_expired)
+      return
     end
+
+    ready[0].each(&:yield_read)
+    ready[1].each(&:yield_write)
   end
 
-  def setup(redis_opts)
-    RedisHA::Connection.new(redis_opts,
-      :retry_timeout => @retry_timeout,
-      :read_timeout => @read_timeout)
+  def await
+    loop do
+      begin
+        await = false
+        select
+
+        @connections.each do |conn|
+          next unless conn.up_or_retry?
+          await = true unless conn.ready?
+        end
+
+        break unless await
+      rescue Errno::EAGAIN, Errno::EINTR
+        next
+      end
+    end
   end
 
 end

data/lib/redis_ha/{base.rb → crdt/base.rb}

@@ -4,7 +4,6 @@ class RedisHA::Base
 
   def initialize(pool, key)
     @pool = pool
-    @pool.ensure_connected
     @key = key
   end
 

data/lib/redis_ha/{counter.rb → crdt/counter.rb}

@@ -21,7 +21,7 @@ class RedisHA::Counter < RedisHA::Base
 
   def get
     versions = pool.get(@key).compact
-    merge_strategy[versions]
+    merge_strategy[versions].to_i
   end
 
   def merge_strategy

data/lib/redis_ha/protocol.rb

@@ -0,0 +1,38 @@
+class RedisHA::Protocol
+
+  def self.request(*args)
+    args.inject("*#{args.size}\r\n") do |s, arg|
+      s << "$#{arg.size}\r\n#{arg}\r\n"
+    end
+  end
+
+  def self.peek?(buf)
+    if ["+", ":", "-"].include?(buf[0])
+      buf[-2..-1] == "\r\n"
+    elsif buf[0] == "$"
+      offset = buf.index("\r\n").to_i
+      return false if offset == 0
+      length = buf[1..offset].to_i
+      return true if length == -1
+      buf.size >= (length + offset + 2)
+    elsif buf[0] == "*"
+      true
+    end
+  end
+
+  def self.parse(buf)
+    case buf[0]
+      when "-" then RuntimeError.new(buf[1..-3])
+      when "+" then buf[1..-3]
+      when ":" then buf[1..-3].to_i
+
+      when "$"
+         buf.sub(/.*\r\n/,"")[0...-2] if buf[1..2] != "-1"
+
+      when "*"
+        RuntimeError.new("multi bulk replies are not supported")
+
+    end
+  end
+
+end

data/lib/redis_ha.rb

@@ -1,16 +1,13 @@
 require "rubygems"
 require "redis"
-require "timeout"
 
-module RedisHA
-  class Error < StandardError
-  end
-end
+module RedisHA; end
 
-require "redis_ha/base"
-require "redis_ha/semaphore"
+require "redis_ha/protocol"
 require "redis_ha/connection"
 require "redis_ha/connection_pool"
-require "redis_ha/hash_map"
-require "redis_ha/set"
-require "redis_ha/counter"
+
+require "redis_ha/crdt/base"
+require "redis_ha/crdt/hash_map"
+require "redis_ha/crdt/set"
+require "redis_ha/crdt/counter"

data/lib/test.rb

@@ -1,10 +1,13 @@
-require "rubygems"; require "redis"; require "pp"; require "ripl"
+require "rubygems"
+ require "redis"
+ require "pp"
+ require "ripl"
 
 def bm(label)
   t = Time.now.to_f
   yield
   d = (Time.now.to_f - t) * 1000
-  puts "#{label}: #{d.to_i}ms"
+  puts "#{label}: #{d.round(2)}ms"
 end
 
 $: << ::File.expand_path("..", __FILE__)
@@ -12,12 +15,9 @@ require "redis_ha"
 
 pool = RedisHA::ConnectionPool.new
 pool.retry_timeout = 0.5
-pool.read_timeout = 0.5
+pool.read_timeout = 10.1
 pool.connect(
-  {:host => "localhost", :port => 6379},
-  {:host => "localhost", :port => 6380},
-  {:host => "localhost", :port => 6381},
-  {:host => "localhost", :port => 6385})
+  {:host => "localhost", :port => 6379})
 
 map = RedisHA::HashMap.new(pool, "fnordmap")
 set = RedisHA::Set.new(pool, "fnordset")
@@ -26,6 +26,21 @@ ctr = RedisHA::Counter.new(pool, "fnordctr")
 Ripl.start :binding => binding
 exit
 
+[100, 1000, 10000].each do |b|
+  bm "#{b}x ping" do
+    b.times do |n|
+      pool.ping
+    end
+  end
+end
+
+while sleep 1
+  bm "1000x ping" do
+    1000.times do |n|
+      pool.ping
+    end
+  end
+end
 
 bm "1000x HashMap.set w/ retries" do
   1000.times do |n|

data/redis_ha.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "redis_ha"
-  s.version     = "0.0.5"
+  s.version     = "0.1.0"
   s.date        = Date.today.to_s
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Paul Asmuth"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis_ha
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-16 00:00:00.000000000 Z
+date: 2012-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &9331680 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,12 @@ dependencies:
         version: 2.2.2
   type: :runtime
   prerelease: false
-  version_requirements: *9331680
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.2.2
 description: Three basic CRDTs (set, hashmap and counter) for redis. Also includes
   a ConnectionPool that allows you to run concurrent redis commands on multiple connections
   w/o using eventmachine/em-hiredis.
@@ -33,13 +38,13 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/redis_ha.rb
-- lib/redis_ha/base.rb
 - lib/redis_ha/connection.rb
 - lib/redis_ha/connection_pool.rb
-- lib/redis_ha/counter.rb
-- lib/redis_ha/hash_map.rb
-- lib/redis_ha/semaphore.rb
-- lib/redis_ha/set.rb
+- lib/redis_ha/crdt/base.rb
+- lib/redis_ha/crdt/counter.rb
+- lib/redis_ha/crdt/hash_map.rb
+- lib/redis_ha/crdt/set.rb
+- lib/redis_ha/protocol.rb
 - lib/test.rb
 - redis_ha.gemspec
 homepage: http://github.com/paulasmuth/redis_ha
@@ -63,7 +68,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: basic CRDTs and a HA connection pool for redis

data/lib/redis_ha/semaphore.rb

@@ -1,20 +0,0 @@
-class RedisHA::Semaphore
-
-  POLL_INTERVAL = 0.001
-
-  def initialize(n)
-    @lock = Mutex.new
-    @n = n
-  end
-
-  def decrement
-    @lock.synchronize do
-      @n -= 1
-    end
-  end
-
-  def wait
-    sleep(POLL_INTERVAL) while @n != 0
-  end
-
-end