redis 3.0.0 → 4.5.0

data/Rakefile

@@ -1,392 +0,0 @@
-require 'rubygems'
-require 'rubygems/package_task'
-require 'rake/testtask'
-
-$:.unshift File.join(File.dirname(__FILE__), 'lib')
-require 'redis/version'
-
-REDIS_DIR = File.expand_path(File.join("..", "test"), __FILE__)
-REDIS_CNF = File.join(REDIS_DIR, "test.conf")
-REDIS_PID = File.join(REDIS_DIR, "db", "redis.pid")
-
-task :default => :run
-
-desc "Run tests and manage server start/stop"
-task :run => [:start, :test, :stop]
-
-desc "Start the Redis server"
-task :start do
-  redis_running = \
-  begin
-    File.exists?(REDIS_PID) && Process.kill(0, File.read(REDIS_PID).to_i)
-  rescue Errno::ESRCH
-    FileUtils.rm REDIS_PID
-    false
-  end
-
-  unless redis_running
-    unless system("which redis-server")
-      STDERR.puts "redis-server not in PATH"
-      exit 1
-    end
-
-    unless system("redis-server #{REDIS_CNF}")
-      STDERR.puts "could not start redis-server"
-      exit 1
-    end
-  end
-end
-
-desc "Stop the Redis server"
-task :stop do
-  if File.exists?(REDIS_PID)
-    Process.kill "INT", File.read(REDIS_PID).to_i
-    FileUtils.rm REDIS_PID
-  end
-end
-
-Rake::TestTask.new do |t|
-  t.options = "-v"
-  t.libs << "test"
-  t.test_files = FileList["test/*_test.rb"]
-end
-
-task :doc => ["doc:generate", "doc:prepare"]
-
-namespace :doc do
-  task :generate do
-    require "shellwords"
-
-    `rm -rf doc`
-
-    current_branch = `git branch`[/^\* (.*)$/, 1]
-
-    begin
-      tags = `git tag -l`.split("\n").sort.reverse
-
-      tags.each do |tag|
-        `git checkout -q #{tag} 2>/dev/null`
-
-        unless $?.success?
-          $stderr.puts "Need a clean working copy. Please git-stash away."
-          exit 1
-        end
-
-        puts tag
-
-        `mkdir -p doc/#{tag}`
-
-        files = `git ls-tree -r HEAD lib`.split("\n").map do |line|
-          line[/\t(.*)$/, 1]
-        end
-
-        opts = [
-          "--title", "A Ruby client for Redis",
-          "--output", "doc/#{tag}",
-          "--no-cache",
-          "--no-save",
-          "-q",
-          *files
-        ]
-
-        `yardoc #{Shellwords.shelljoin opts}`
-      end
-    ensure
-      `git checkout -q #{current_branch}`
-    end
-  end
-
-  task :prepare do
-    versions = `git tag -l`.split("\n").grep(/^v/).sort
-    latest_version = versions.last
-
-    File.open("doc/.htaccess", "w") do |file|
-      file.puts "RedirectMatch 302 ^/?$ /#{latest_version}"
-    end
-
-    File.open("doc/robots.txt", "w") do |file|
-      file.puts "User-Agent: *"
-
-      (versions - [latest_version]).each do |version|
-        file.puts "Disallow: /#{version}"
-      end
-    end
-
-    google_analytics = <<-EOS
-    <script type="text/javascript">
-
-      var _gaq = _gaq || [];
-      _gaq.push(['_setAccount', 'UA-11356145-2']);
-      _gaq.push(['_trackPageview']);
-
-      (function() {
-        var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
-        ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
-        var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
-      })();
-
-    </script>
-    EOS
-
-    Dir["doc/**/*.html"].each do |path|
-      lines = IO.readlines(path)
-
-      File.open(path, "w") do |file|
-        lines.each do |line|
-          if line.include?("</head>")
-            file.write(google_analytics)
-          end
-
-          file.write(line)
-        end
-      end
-    end
-  end
-
-  task :deploy do
-    system "rsync --del -avz doc/ redis-rb.keyvalue.org:deploys/redis-rb.keyvalue.org/"
-  end
-end
-
-class Source
-
-  MATCHER = "(?:\\s{%d}#[^\\n]*\\n)*^\\s{%d}def ([a-z_?]+)(?:\(.*?\))?\\n.*?^\\s{%d}end\\n\\n"
-
-  def initialize(data, options = {})
-    @doc = parse(File.read(data), options)
-  end
-
-  def methods
-    @doc.select do |d|
-      d.is_a?(Method)
-    end.map do |d|
-      d.name
-    end
-  end
-
-  def move(a, b)
-    ao = @doc.find { |m| m.is_a?(Method) && m.name == a }
-    bo = @doc.find { |m| m.is_a?(Method) && m.name == b }
-    ai = @doc.index(ao)
-    bi = @doc.index(bo)
-
-    @doc.delete_at(ai)
-    @doc.insert(bi, ao)
-
-    nil
-  end
-
-  def to_s
-    @doc.join
-  end
-
-  protected
-
-  def parse(data, options = {})
-    re = Regexp.new(MATCHER % ([options[:indent]] * 3), Regexp::MULTILINE)
-    tail = data.dup
-    doc = []
-
-    while match = re.match(tail)
-      doc << match.pre_match
-      doc << Method.new(match)
-      tail = match.post_match
-    end
-
-    doc << tail if tail
-    doc
-  end
-
-  class Method
-
-    def initialize(match)
-      @match = match
-    end
-
-    def name
-      @match[1]
-    end
-
-    def to_s
-      @match[0]
-    end
-  end
-end
-
-namespace :commands do
-  def redis_commands
-    $redis_commands ||= doc.keys.map do |key|
-      key.split(" ").first.downcase
-    end.uniq
-  end
-
-  def doc
-    $doc ||= begin
-      require "open-uri"
-      require "json"
-
-      JSON.parse(open("https://github.com/antirez/redis-doc/raw/master/commands.json").read)
-    end
-  end
-
-  task :order do
-    require "json"
-
-    reference = if File.exist?(".order")
-                  JSON.parse(File.read(".order"))
-                else
-                  {}
-                end
-
-    buckets = {}
-    doc.each do |k, v|
-      buckets[v["group"]] ||= []
-      buckets[v["group"]] << k.split.first.downcase
-      buckets[v["group"]].uniq!
-    end
-
-    result = (reference.keys + (buckets.keys - reference.keys)).map do |g|
-      [g, reference[g] + (buckets[g] - reference[g])]
-    end
-
-    File.open(".order", "w") do |f|
-      f.write(JSON.pretty_generate(Hash[result]))
-    end
-  end
-
-  def reorder(file, options = {})
-    require "json"
-    require "set"
-
-    STDERR.puts "reordering #{file}..."
-
-    reference = if File.exist?(".order")
-                  JSON.parse(File.read(".order"))
-                else
-                  {}
-                end
-
-    dst = Source.new(file, options)
-
-    src_methods = reference.map { |k, v| v }.flatten
-    dst_methods = dst.methods
-
-    src_set = Set.new(src_methods)
-    dst_set = Set.new(dst_methods)
-
-    intersection = src_set & dst_set
-    intersection.delete("initialize")
-
-    loop do
-      src_methods = reference.map { |k, v| v }.flatten
-      dst_methods = dst.methods
-
-      src_methods = src_methods.select do |m|
-        intersection.include?(m)
-      end
-
-      dst_methods = dst_methods.select do |m|
-        intersection.include?(m)
-      end
-
-      if src_methods == dst_methods
-        break
-      end
-
-      rv = yield(src_methods, dst_methods, dst)
-      break if rv == false
-    end
-
-    File.open(file, "w") do |f|
-      f.write(dst.to_s)
-    end
-  end
-
-  task :reorder do
-    blk = lambda do |src_methods, dst_methods, dst|
-      src_methods.zip(dst_methods).each do |a, b|
-        if a != b
-          dst.move(a, b)
-          break
-        end
-      end
-    end
-
-    reorder "lib/redis.rb", :indent => 2, &blk
-    reorder "lib/redis/distributed.rb", :indent => 4, &blk
-  end
-
-  def missing(file, options = {})
-    src = Source.new(file, options)
-
-    defined_methods = src.methods.map(&:downcase)
-    required_methods = redis_commands.map(&:downcase)
-
-    STDOUT.puts "missing in #{file}:"
-    STDOUT.puts (required_methods - defined_methods).inspect
-  end
-
-  task :missing do
-    missing "lib/redis.rb", :indent => 2
-    missing "lib/redis/distributed.rb", :indent => 4
-  end
-
-  def document(file)
-    source = File.read(file)
-
-    doc.each do |name, command|
-      source.sub!(/(?:^ *# .*\n)*(^ *#\n(^ *# .+?\n)*)*^( *)def #{name.downcase}(\(|$)/) do
-        extra_comments, indent, extra_args = $1, $3, $4
-        comment = "#{indent}# #{command["summary"].strip}."
-
-        IO.popen("par p#{2 + indent.size} 80", "r+") do |io|
-          io.puts comment
-          io.close_write
-          comment = io.read
-        end
-
-        "#{comment}#{extra_comments}#{indent}def #{name.downcase}#{extra_args}"
-      end
-    end
-
-    File.open(file, "w") { |f| f.write(source) }
-  end
-
-  task :doc do
-    document "lib/redis.rb"
-    document "lib/redis/distributed.rb"
-  end
-
-  task :verify do
-    require "redis"
-    require "stringio"
-
-    require "./test/helper"
-
-    OPTIONS[:logger] = Logger.new("./tmp/log")
-
-    Rake::Task["test:ruby"].invoke
-
-    redis = Redis.new
-
-    report = ["Command", "\033[0mDefined?\033[0m", "\033[0mTested?\033[0m"]
-
-    yes, no = "\033[1;32mYes\033[0m", "\033[1;31mNo\033[0m"
-
-    log = File.read("./tmp/log")
-
-    redis_commands.sort.each do |name, _|
-      defined, tested = redis.respond_to?(name), log[">> #{name.upcase}"]
-
-      next if defined && tested
-
-      report << name
-      report << (defined ? yes : no)
-      report << (tested ? yes : no)
-    end
-
-    IO.popen("rs 0 3", "w") do |io|
-      io.puts report.join("\n")
-    end
-  end
-end

data/benchmarking/logging.rb

@@ -1,62 +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|
-  benchmark "#{redis.client.logger.class} on #{Logger::SEV_LABEL[redis.client.logger.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/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')