redis 3.3.5 → 4.1.0

data/benchmarking/logging.rb

@@ -1,71 +0,0 @@
-# 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|
-  logger = redis.client.logger
-
-  case logger
-  when Logger
-    level = Logger::SEV_LABEL[logger.level]
-  when Log4r::Logger
-    level = logger.levels[logger.level]
-  end
-
-  benchmark "#{logger.class} on #{level}" do
-    stress(redis)
-  end
-end
-
-run 10

data/benchmarking/pipeline.rb

@@ -1,51 +0,0 @@
-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

@@ -1,21 +0,0 @@
-# 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

@@ -1,24 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,114 +0,0 @@
-# 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

@@ -1,43 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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)