redis 2.1.1 → 2.2.0

data/benchmarking/logging.rb

@@ -0,0 +1,62 @@
+# Run with
+#
+#   $ ruby -Ilib benchmarking/logging.rb
+#
+
+begin
+  require "bench"
+rescue LoadError
+  $stderr.puts "`gem install bench` and try again."
+  exit 1
+end
+
+require "redis"
+require "logger"
+
+def log(level, namespace = nil)
+  logger = (namespace || Kernel).const_get(:Logger).new("/dev/null")
+  logger.level = (namespace || Logger).const_get(level)
+  logger
+end
+
+def stress(redis)
+  redis.flushdb
+
+  n = (ARGV.shift || 2000).to_i
+
+  n.times do |i|
+    key = "foo:#{i}"
+    redis.set key, i
+    redis.get key
+  end
+end
+
+default = Redis.new
+
+logging_redises = [
+  Redis.new(:logger => log(:DEBUG)),
+  Redis.new(:logger => log(:INFO)),
+]
+
+begin
+  require "log4r"
+
+  logging_redises += [
+    Redis.new(:logger => log(:DEBUG, Log4r)),
+    Redis.new(:logger => log(:INFO, Log4r)),
+  ]
+rescue LoadError
+  $stderr.puts "Log4r not installed. `gem install log4r` if you want to compare it against Ruby's Logger (spoiler: it's much faster)."
+end
+
+benchmark "Default options (no logger)" do
+  stress(default)
+end
+
+logging_redises.each do |redis|
+  benchmark "#{redis.client.logger.class} on #{Logger::SEV_LABEL[redis.client.logger.level]}" do
+    stress(redis)
+  end
+end
+
+run 10

data/benchmarking/pipeline.rb

@@ -0,0 +1,51 @@
+require "benchmark"
+
+$:.push File.join(File.dirname(__FILE__), 'lib')
+
+require 'redis'
+
+ITERATIONS = 10000
+
+@r = Redis.new
+
+Benchmark.bmbm do |benchmark|
+  benchmark.report("set") do
+    @r.flushdb
+
+    ITERATIONS.times do |i|
+      @r.set("foo#{i}", "Hello world!")
+      @r.get("foo#{i}")
+    end
+  end
+
+  benchmark.report("set (pipelined)") do
+    @r.flushdb
+
+    @r.pipelined do
+      ITERATIONS.times do |i|
+        @r.set("foo#{i}", "Hello world!")
+        @r.get("foo#{i}")
+      end
+    end
+  end
+
+  benchmark.report("lpush+ltrim") do
+    @r.flushdb
+
+    ITERATIONS.times do |i|
+      @r.lpush "lpush#{i}", i
+      @r.ltrim "ltrim#{i}", 0, 30
+    end
+  end
+
+  benchmark.report("lpush+ltrim (pipelined)") do
+    @r.flushdb
+
+    @r.pipelined do
+      ITERATIONS.times do |i|
+        @r.lpush "lpush#{i}", i
+        @r.ltrim "ltrim#{i}", 0, 30
+      end
+    end
+  end
+end

data/benchmarking/speed.rb

@@ -0,0 +1,21 @@
+# Run with
+#
+#   $ ruby -Ilib benchmarking/speed.rb
+#
+
+require "benchmark"
+require "redis"
+
+r = Redis.new
+n = (ARGV.shift || 20000).to_i
+
+elapsed = Benchmark.realtime do
+  # n sets, n gets
+  n.times do |i|
+    key = "foo#{i}"
+    r[key] = key * 10
+    r[key]
+  end
+end
+
+puts '%.2f Kops' % (2 * n / 1000 / elapsed)

data/benchmarking/suite.rb

@@ -0,0 +1,24 @@
+require 'fileutils'
+
+def run_in_background(command)
+  fork { system command }
+end
+
+def with_all_segments(&block)
+  0.upto(9) do |segment_number|
+    block_size = 100000
+    start_index = segment_number * block_size
+    end_index = start_index + block_size - 1
+    block.call(start_index, end_index)
+  end
+end
+
+#with_all_segments do |start_index, end_index|
+#  puts "Initializing keys from #{start_index} to #{end_index}"
+#  system "ruby worker.rb initialize #{start_index} #{end_index} 0"
+#end
+
+with_all_segments do |start_index, end_index|
+  run_in_background "ruby worker.rb write #{start_index} #{end_index} 10"
+  run_in_background "ruby worker.rb read #{start_index} #{end_index} 1"
+end

data/benchmarking/thread_safety.rb

@@ -0,0 +1,38 @@
+# Run with
+#
+#   $ ruby -Ilib benchmarking/thread_safety.rb
+#
+
+begin
+  require "bench"
+rescue LoadError
+  $stderr.puts "`gem install bench` and try again."
+  exit 1
+end
+
+require "redis"
+
+def stress(redis)
+  redis.flushdb
+
+  n = (ARGV.shift || 2000).to_i
+
+  n.times do |i|
+    key = "foo:#{i}"
+    redis.set key, i
+    redis.get key
+  end
+end
+
+thread_unsafe = Redis.new(:thread_safe => false)
+thread_safe = Redis.new(:thread_safe => true)
+
+benchmark "Thread-unsafe" do
+  stress(thread_unsafe)
+end
+
+benchmark "Thread-safe" do
+  stress(thread_safe)
+end
+
+run 10

data/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/examples/basic.rb

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

data/examples/dist_redis.rb

@@ -0,0 +1,43 @@
+require "redis"
+require "redis/distributed"
+
+r = Redis::Distributed.new %w[redis://localhost:6379 redis://localhost:6380 redis://localhost:6381 redis://localhost:6382]
+
+r.flushdb
+
+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.rpush 'listor', 'foo1'
+r.rpush 'listor', 'foo2'
+r.rpush 'listor', 'foo3'
+r.rpush 'listor', 'foo4'
+r.rpush 'listor', 'foo5'
+
+p r.rpop('listor')
+p r.rpop('listor')
+p r.rpop('listor')
+p r.rpop('listor')
+p r.rpop('listor')
+
+puts "key distribution:"
+
+r.ring.nodes.each do |node|
+  p [node.client, node.keys("*")]
+end
+r.flushdb
+p r.keys('*')

data/examples/incr-decr.rb

@@ -0,0 +1,17 @@
+require 'redis'
+
+r = Redis.new
+
+puts
+p 'incr'
+r.del '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/examples/list.rb

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

data/examples/pubsub.rb

@@ -0,0 +1,31 @@
+require "redis"
+
+puts <<-EOS
+To play with this example use redis-cli from another terminal, like this:
+
+  $ redis-cli publish one hello
+
+Finally force the example to exit sending the 'exit' message with:
+
+  $ redis-cli publish two exit
+
+EOS
+
+redis = Redis.connect
+
+trap(:INT) { puts; exit }
+
+redis.subscribe(:one, :two) do |on|
+  on.subscribe do |channel, subscriptions|
+    puts "Subscribed to ##{channel} (#{subscriptions} subscriptions)"
+  end
+
+  on.message do |channel, message|
+    puts "##{channel}: #{message}"
+    redis.unsubscribe if message == "exit"
+  end
+
+  on.unsubscribe do |channel, subscriptions|
+    puts "Unsubscribed from ##{channel} (#{subscriptions} subscriptions)"
+  end
+end

data/examples/sets.rb

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