discourse-redis 3.2.2

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/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/consistency.rb

@@ -0,0 +1,114 @@
+# This file implements a simple consistency test for Redis-rb (or any other
+# Redis environment if you pass a different client object) where a client
+# writes to the database using INCR in order to increment keys, but actively
+# remember the value the key should have. Before every write a read is performed
+# to check if the value in the database matches the value expected.
+#
+# In this way this program can check for lost writes, or acknowledged writes
+# that were executed.
+#
+# Copyright (C) 2013-2014 Salvatore Sanfilippo <antirez@gmail.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'redis'
+
+class ConsistencyTester
+    def initialize(redis)
+        @r = redis
+        @working_set = 10000
+        @keyspace = 100000
+        @writes = 0
+        @reads = 0
+        @failed_writes = 0
+        @failed_reads = 0
+        @lost_writes = 0
+        @not_ack_writes = 0
+        @delay = 0
+        @cached = {} # We take our view of data stored in the DB.
+        @prefix = [Process.pid.to_s,Time.now.usec,@r.object_id,""].join("|")
+        @errtime = {}
+    end
+
+    def genkey
+        # Write more often to a small subset of keys
+        ks = rand() > 0.5 ? @keyspace : @working_set
+        @prefix+"key_"+rand(ks).to_s
+    end
+
+    def check_consistency(key,value)
+        expected = @cached[key]
+        return if !expected  # We lack info about previous state.
+        if expected > value
+            @lost_writes += expected-value
+        elsif expected < value
+            @not_ack_writes += value-expected
+        end
+    end
+
+    def puterr(msg)
+        if !@errtime[msg] || Time.now.to_i != @errtime[msg]
+            puts msg
+        end
+        @errtime[msg] = Time.now.to_i
+    end
+
+    def test
+        last_report = Time.now.to_i
+        while true
+            # Read
+            key = genkey
+            begin
+                val = @r.get(key)
+                check_consistency(key,val.to_i)
+                @reads += 1
+            rescue => e
+                puterr "Reading: #{e.class}: #{e.message} (#{e.backtrace.first})"
+                @failed_reads += 1
+            end
+
+            # Write
+            begin
+                @cached[key] = @r.incr(key).to_i
+                @writes += 1
+            rescue => e
+                puterr "Writing: #{e.class}: #{e.message} (#{e.backtrace.first})"
+                @failed_writes += 1
+            end
+
+            # Report
+            sleep @delay
+            if Time.now.to_i != last_report
+                report = "#{@reads} R (#{@failed_reads} err) | " +
+                         "#{@writes} W (#{@failed_writes} err) | "
+                report += "#{@lost_writes} lost | " if @lost_writes > 0
+                report += "#{@not_ack_writes} noack | " if @not_ack_writes > 0
+                last_report = Time.now.to_i
+                puts report
+            end
+        end
+    end
+end
+
+Sentinels = [{:host => "127.0.0.1", :port => 26379},
+             {:host => "127.0.0.1", :port => 26380}]
+r = Redis.new(:url => "redis://master1", :sentinels => Sentinels, :role => :master)
+tester = ConsistencyTester.new(r)
+tester.test

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,37 @@
+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.new
+
+trap(:INT) { puts; exit }
+
+begin
+  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
+rescue Redis::BaseConnectionError => error
+  puts "#{error}, retrying in 1s"
+  sleep 1
+  retry
+end

data/examples/sentinel.rb

@@ -0,0 +1,41 @@
+require 'redis'
+
+# This example creates a master-slave setup with a sentinel, then connects to
+# it and sends write commands in a loop.
+#
+# After 30 seconds, the master dies. You will be able to see how a new master
+# is elected and things continue to work as if nothing happened.
+#
+# To run this example:
+#
+#   $ ruby -I./lib examples/sentinel.rb
+#
+
+at_exit do
+  begin
+    Process.kill(:INT, $redises)
+  rescue Errno::ESRCH
+  end
+
+  Process.waitall
+end
+
+$redises = spawn("examples/sentinel/start")
+
+Sentinels = [{:host => "127.0.0.1", :port => 26379},
+             {:host => "127.0.0.1", :port => 26380}]
+r = Redis.new(:url => "redis://master1", :sentinels => Sentinels, :role => :master)
+
+# Set keys into a loop.
+#
+# The example traps errors so that you can actually try to failover while
+# running the script to see redis-rb reconfiguring.
+(0..1000000).each{|i|
+    begin
+        r.set(i,i)
+        $stdout.write("SET (#{i} times)\n") if i % 100 == 0
+    rescue => e
+        $stdout.write("E")
+    end
+    sleep(0.01)
+}