mikeg-vanity 1.3.0

data/vendor/redis-rb/benchmarking/worker.rb

@@ -0,0 +1,71 @@
+BENCHMARK_ROOT = File.dirname(__FILE__)
+REDIS_ROOT = File.join(BENCHMARK_ROOT, "..", "lib")
+
+$: << REDIS_ROOT
+require 'redis'
+require 'benchmark'
+
+def show_usage
+  puts <<-EOL
+    Usage: worker.rb [read:write] <start_index> <end_index> <sleep_msec>
+  EOL
+end
+
+def shift_from_argv
+  value = ARGV.shift
+  unless value
+    show_usage
+    exit -1
+  end
+  value
+end
+
+operation = shift_from_argv.to_sym
+start_index = shift_from_argv.to_i
+end_index = shift_from_argv.to_i
+sleep_msec = shift_from_argv.to_i
+sleep_duration = sleep_msec/1000.0
+
+redis = Redis.new
+
+case operation
+  when :initialize
+
+    start_index.upto(end_index) do |i|
+      redis[i] = 0
+    end
+
+  when :clear
+
+    start_index.upto(end_index) do |i|
+      redis.delete(i)
+    end
+
+  when :read, :write
+
+    puts "Starting to #{operation} at segment #{end_index + 1}"
+
+    loop do
+      t1 = Time.now
+      start_index.upto(end_index) do |i|
+        case operation
+          when :read
+            redis.get(i)
+          when :write
+            redis.incr(i)
+          else
+            raise "Unknown operation: #{operation}"
+        end
+        sleep sleep_duration
+      end
+      t2 = Time.now
+
+      requests_processed = end_index - start_index
+      time = t2 - t1
+      puts "#{t2.strftime("%H:%M")} [segment #{end_index + 1}] : Processed #{requests_processed} requests in #{time} seconds - #{(requests_processed/time).round} requests/sec"
+    end
+
+  else
+    raise "Unknown operation: #{operation}"
+end
+

data/vendor/redis-rb/bin/distredis

@@ -0,0 +1,33 @@
+require 'fileutils'
+
+class RedisCluster
+  
+  def initialize(opts={})
+    opts = {:port => 6379, :host => 'localhost', :basedir => "#{Dir.pwd}/rdsrv" }.merge(opts)
+    FileUtils.mkdir_p opts[:basedir]
+    opts[:size].times do |i|
+      port = opts[:port] + i
+      FileUtils.mkdir_p "#{opts[:basedir]}/#{port}"
+      File.open("#{opts[:basedir]}/#{port}.conf", 'w'){|f| f.write(make_config(port, "#{opts[:basedir]}/#{port}", "#{opts[:basedir]}/#{port}.log"))}
+      system(%Q{#{File.join(File.expand_path(File.dirname(__FILE__)), "../redis/redis-server #{opts[:basedir]}/#{port}.conf &" )}})
+    end  
+  end
+
+  def make_config(port=6379, data=port, logfile='stdout', loglevel='debug')
+    config = %Q{
+timeout 300
+save 900 1
+save 300 10
+save 60 10000
+dir #{data}
+loglevel #{loglevel}
+logfile #{logfile}
+databases 16
+port #{port}
+    }
+  end
+  
+end
+
+
+RedisCluster.new :size => 4

data/vendor/redis-rb/examples/basic.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'redis'
+
+r = Redis.new
+
+r.delete('foo')
+
+puts 
+
+p'set foo to "bar"'
+r['foo'] = 'bar'
+
+puts
+
+p 'value of foo'
+p r['foo']

data/vendor/redis-rb/examples/incr-decr.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'redis'
+
+r = Redis.new
+
+puts
+p 'incr'
+r.delete 'counter'
+
+p r.incr('counter')
+p r.incr('counter')
+p r.incr('counter')
+
+puts
+p 'decr'
+p r.decr('counter')
+p r.decr('counter')
+p r.decr('counter')

data/vendor/redis-rb/examples/list.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'redis'
+
+r = Redis.new
+
+r.delete 'logs'
+
+puts
+
+p "pushing log messages into a LIST"
+r.push_tail 'logs', 'some log message'
+r.push_tail 'logs', 'another log message'
+r.push_tail 'logs', 'yet another log message'
+r.push_tail 'logs', 'also another log message'
+
+puts
+p 'contents of logs LIST'
+
+p r.list_range('logs', 0, -1)
+
+puts
+p 'Trim logs LIST to last 2 elements(easy circular buffer)'
+
+r.list_trim('logs', -2, -1)
+
+p r.list_range('logs', 0, -1)

data/vendor/redis-rb/examples/sets.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'redis'
+
+r = Redis.new
+
+r.delete 'foo-tags'
+r.delete 'bar-tags'
+
+puts
+p "create a set of tags on foo-tags"
+
+r.set_add 'foo-tags', 'one'
+r.set_add 'foo-tags', 'two'
+r.set_add 'foo-tags', 'three'
+
+puts
+p "create a set of tags on bar-tags"
+
+r.set_add 'bar-tags', 'three'
+r.set_add 'bar-tags', 'four'
+r.set_add 'bar-tags', 'five'
+
+puts
+p 'foo-tags'
+
+p r.set_members('foo-tags')
+
+puts
+p 'bar-tags'
+
+p r.set_members('bar-tags')
+
+puts
+p 'intersection of foo-tags and bar-tags'
+
+p r.set_intersect('foo-tags', 'bar-tags')

data/vendor/redis-rb/lib/dist_redis.rb

@@ -0,0 +1,124 @@
+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
+
+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/vendor/redis-rb/lib/hash_ring.rb

@@ -0,0 +1,128 @@
+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;
+                }
+            }
+            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
+        return upper
+      end
+
+    end
+  end
+
+end
+
+# ring = HashRing.new ['server1', 'server2', 'server3']
+# p ring
+# #
+# p ring.get_node "kjhjkjlkjlkkh"
+#