chimera 0.0.1

data/lib/redis/counter.rb

@@ -0,0 +1,94 @@
+class Redis
+  #
+  # Class representing a Redis counter.  This functions like a proxy class, in
+  # that you can say @object.counter_name to get the value and then
+  # @object.counter_name.increment to operate on it.  You can use this
+  # directly, or you can use the counter :foo class method in your
+  # class to define a counter.
+  #
+  class Counter
+    require 'redis/helpers/core_commands'
+    include Redis::Helpers::CoreCommands
+
+    attr_reader :key, :options, :redis
+    def initialize(key, redis=$redis, options={})
+      @key = key
+      @redis = redis
+      @options = options
+      @options[:start] ||= 0
+      @redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
+    end
+
+    # Reset the counter to its starting value.  Not atomic, so use with care.
+    # Normally only useful if you're discarding all sub-records associated
+    # with a parent and starting over (for example, restarting a game and
+    # disconnecting all players).
+    def reset(to=options[:start])
+      redis.set key, to.to_i
+    end
+
+    # Returns the current value of the counter.  Normally just calling the
+    # counter will lazily fetch the value, and only update it if increment
+    # or decrement is called.  This forces a network call to redis-server
+    # to get the current value.
+    def value
+      redis.get(key).to_i
+    end
+    alias_method :get, :value
+
+    # Increment the counter atomically and return the new value.  If passed
+    # a block, that block will be evaluated with the new value of the counter
+    # as an argument. If the block returns nil or throws an exception, the
+    # counter will automatically be decremented to its previous value.  This
+    # method is aliased as incr() for brevity.
+    def increment(by=1, &block)
+      val = redis.incr(key, by).to_i
+      block_given? ? rewindable_block(:decrement, val, &block) : val
+    end
+    alias_method :incr, :increment
+
+    # Decrement the counter atomically and return the new value.  If passed
+    # a block, that block will be evaluated with the new value of the counter
+    # as an argument. If the block returns nil or throws an exception, the
+    # counter will automatically be incremented to its previous value.  This
+    # method is aliased as incr() for brevity.
+    def decrement(by=1, &block)
+      val = redis.decr(key, by).to_i
+      block_given? ? rewindable_block(:increment, val, &block) : val
+    end
+    alias_method :decr, :decrement
+
+    ##
+    # Proxy methods to help make @object.counter == 10 work
+    def to_s; value.to_s; end
+    alias_method :to_str, :to_s
+    alias_method :to_i, :value
+    def nil?; value.nil? end
+
+    # Math ops
+    %w(== < > <= >=).each do |m|
+      class_eval <<-EndOverload
+        def #{m}(x)
+          value #{m} x
+        end
+      EndOverload
+    end
+   
+    private
+
+    # Implements atomic increment/decrement blocks
+    def rewindable_block(rewind, value, &block)
+      raise ArgumentError, "Missing block to rewindable_block somehow" unless block_given?
+      ret = nil
+      begin
+        ret = yield value
+      rescue
+        send(rewind)
+        raise
+      end
+      send(rewind) if ret.nil?
+      ret
+    end
+  end
+end
+

data/lib/redis/dist_redis.rb

@@ -0,0 +1,149 @@
+require 'redis'
+require 'hash_ring'
+class DistRedis
+  attr_reader :ring
+  def initialize(opts={})
+    hosts = []
+
+    db = opts[:db] || nil
+    timeout = opts[:timeout] || nil
+
+    raise Error, "No hosts given" unless opts[:hosts]
+
+    opts[:hosts].each do |h|
+      host, port = h.split(':')
+      hosts << Redis.new(:host => host, :port => port, :db => db, :timeout => timeout)
+    end
+
+    @ring = HashRing.new hosts
+  end
+
+  def node_for_key(key)
+    key = $1 if key =~ /\{(.*)?\}/
+    @ring.get_node(key)
+  end
+
+  def add_server(server)
+    server, port = server.split(':')
+    @ring.add_node Redis.new(:host => server, :port => port)
+  end
+
+  def method_missing(sym, *args, &blk)
+    if redis = node_for_key(args.first.to_s)
+      redis.send sym, *args, &blk
+    else
+      super
+    end
+  end
+
+  def keys(glob)
+    @ring.nodes.map do |red|
+      red.keys(glob)
+    end
+  end
+
+  def save
+    on_each_node :save
+  end
+
+  def bgsave
+    on_each_node :bgsave
+  end
+
+  def quit
+    on_each_node :quit
+  end
+
+  def flush_all
+    on_each_node :flush_all
+  end
+  alias_method :flushall, :flush_all
+
+  def flush_db
+    on_each_node :flush_db
+  end
+  alias_method :flushdb, :flush_db
+
+  def delete_cloud!
+    @ring.nodes.each do |red|
+      red.keys("*").each do |key|
+        red.delete key
+      end
+    end
+  end
+
+  def on_each_node(command, *args)
+    @ring.nodes.each do |red|
+      red.send(command, *args)
+    end
+  end
+
+  def mset()
+
+  end
+
+  def mget(*keyz)
+    results = {}
+    kbn = keys_by_node(keyz)
+    kbn.each do |node, node_keyz|
+      node.mapped_mget(*node_keyz).each do |k, v|
+        results[k] = v
+      end
+    end
+    keyz.flatten.map { |k| results[k] }
+  end
+
+  def keys_by_node(*keyz)
+    keyz.flatten.inject({}) do |kbn, k|
+      node = node_for_key(k)
+      next if kbn[node] && kbn[node].include?(k)
+      kbn[node] ||= []
+      kbn[node] << k
+      kbn
+    end
+  end
+
+end
+
+
+if __FILE__ == $0
+
+r = DistRedis.new 'localhost:6379', 'localhost:6380', 'localhost:6381', 'localhost:6382'
+  r['urmom'] = 'urmom'
+  r['urdad'] = 'urdad'
+  r['urmom1'] = 'urmom1'
+  r['urdad1'] = 'urdad1'
+  r['urmom2'] = 'urmom2'
+  r['urdad2'] = 'urdad2'
+  r['urmom3'] = 'urmom3'
+  r['urdad3'] = 'urdad3'
+  p r['urmom']
+  p r['urdad']
+  p r['urmom1']
+  p r['urdad1']
+  p r['urmom2']
+  p r['urdad2']
+  p r['urmom3']
+  p r['urdad3']
+
+  r.push_tail 'listor', 'foo1'
+  r.push_tail 'listor', 'foo2'
+  r.push_tail 'listor', 'foo3'
+  r.push_tail 'listor', 'foo4'
+  r.push_tail 'listor', 'foo5'
+
+  p r.pop_tail('listor')
+  p r.pop_tail('listor')
+  p r.pop_tail('listor')
+  p r.pop_tail('listor')
+  p r.pop_tail('listor')
+
+  puts "key distribution:"
+
+  r.ring.nodes.each do |red|
+    p [red.port, red.keys("*")]
+  end
+  r.delete_cloud!
+  p r.keys('*')
+
+end

data/lib/redis/hash_ring.rb

@@ -0,0 +1,135 @@
+require 'zlib'
+
+class HashRing
+
+  POINTS_PER_SERVER = 160 # this is the default in libmemcached
+
+  attr_reader :ring, :sorted_keys, :replicas, :nodes
+
+  # nodes is a list of objects that have a proper to_s representation.
+  # replicas indicates how many virtual points should be used pr. node,
+  # replicas are required to improve the distribution.
+  def initialize(nodes=[], replicas=POINTS_PER_SERVER)
+    @replicas = replicas
+    @ring = {}
+    @nodes = []
+    @sorted_keys = []
+    nodes.each do |node|
+      add_node(node)
+    end
+  end
+
+  # Adds a `node` to the hash ring (including a number of replicas).
+  def add_node(node)
+    @nodes << node
+    @replicas.times do |i|
+      key = Zlib.crc32("#{node}:#{i}")
+      @ring[key] = node
+      @sorted_keys << key
+    end
+    @sorted_keys.sort!
+  end
+
+  def remove_node(node)
+    @nodes.reject!{|n| n.to_s == node.to_s}
+    @replicas.times do |i|
+      key = Zlib.crc32("#{node}:#{i}")
+      @ring.delete(key)
+      @sorted_keys.reject! {|k| k == key}
+    end
+  end
+
+  # get the node in the hash ring for this key
+  def get_node(key)
+    get_node_pos(key)[0]
+  end
+
+  def get_node_pos(key)
+    return [nil,nil] if @ring.size == 0
+    crc = Zlib.crc32(key)
+    idx = HashRing.binary_search(@sorted_keys, crc)
+    return [@ring[@sorted_keys[idx]], idx]
+  end
+
+  def iter_nodes(key)
+    return [nil,nil] if @ring.size == 0
+    node, pos = get_node_pos(key)
+    @sorted_keys[pos..-1].each do |k|
+      yield @ring[k]
+    end
+  end
+
+  class << self
+
+    # gem install RubyInline to use this code
+    # Native extension to perform the binary search within the hashring.
+    # There's a pure ruby version below so this is purely optional
+    # for performance.  In testing 20k gets and sets, the native
+    # binary search shaved about 12% off the runtime (9sec -> 8sec).
+    begin
+      require 'inline'
+      inline do |builder|
+        builder.c <<-EOM
+        int binary_search(VALUE ary, unsigned int r) {
+            int upper = RARRAY_LEN(ary) - 1;
+            int lower = 0;
+            int idx = 0;
+
+            while (lower <= upper) {
+                idx = (lower + upper) / 2;
+
+                VALUE continuumValue = RARRAY_PTR(ary)[idx];
+                unsigned int l = NUM2UINT(continuumValue);
+                if (l == r) {
+                    return idx;
+                }
+                else if (l > r) {
+                    upper = idx - 1;
+                }
+                else {
+                    lower = idx + 1;
+                }
+            }
+            if (upper < 0) {
+              upper = RARRAY_LEN(ary) - 1;
+            }
+            return upper;
+        }
+        EOM
+      end
+    rescue Exception => e
+      # Find the closest index in HashRing with value <= the given value
+      def binary_search(ary, value, &block)
+        upper = ary.size - 1
+        lower = 0
+        idx = 0
+
+        while(lower <= upper) do
+          idx = (lower + upper) / 2
+          comp = ary[idx] <=> value
+
+          if comp == 0
+            return idx
+          elsif comp > 0
+            upper = idx - 1
+          else
+            lower = idx + 1
+          end
+        end
+
+        if upper < 0
+          upper = ary.size - 1
+        end
+        return upper
+      end
+
+    end
+  end
+
+end
+
+# ring = HashRing.new ['server1', 'server2', 'server3']
+# p ring
+# #
+# p ring.get_node "kjhjkjlkjlkkh"
+#

data/lib/redis/helpers/core_commands.rb

@@ -0,0 +1,46 @@
+class Redis
+  module Helpers
+    # These are core commands that all types share (rename, etc)
+    module CoreCommands
+      def exists?
+        redis.exists key
+      end
+      
+      def delete
+        redis.del key
+      end
+      alias_method :del, :delete
+      alias_method :clear, :delete
+      
+      def type
+        redis.type key
+      end
+      
+      def rename(name, setkey=true)
+        dest = name.is_a?(self.class) ? name.key : name
+        ret  = redis.rename key, dest
+        @key = dest if ret && setkey
+        ret
+      end
+
+      def renamenx(name, setkey=true)
+        dest = name.is_a?(self.class) ? name.key : name
+        ret  = redis.renamenx key, dest
+        @key = dest if ret && setkey
+        ret
+      end
+    
+      def expire(seconds)
+        redis.expire key, seconds
+      end
+
+      def expireat(unixtime)
+        redis.expire key, unixtime
+      end
+    
+      def move(dbindex)
+        redis.move key, dbindex
+      end
+    end
+  end
+end

data/lib/redis/helpers/serialize.rb

@@ -0,0 +1,25 @@
+class Redis
+  module Helpers
+    module Serialize
+      include Marshal
+
+      def to_redis(value)
+        case value
+        when String, Fixnum, Bignum, Float
+          value
+        else
+          dump(value)
+        end
+      end
+    
+      def from_redis(value)
+        case value
+        when Array
+          value.collect{|v| from_redis(v)}
+        else
+          restore(value) rescue value
+        end
+      end
+    end
+  end
+end