redis 3.3.5 → 4.5.1

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)

data/examples/pubsub.rb

@@ -1,37 +0,0 @@
-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/sentinel.conf

@@ -1,9 +0,0 @@
-sentinel monitor master1 127.0.0.1 6380 2
-sentinel down-after-milliseconds master1 5000
-sentinel failover-timeout master1 15000
-sentinel parallel-syncs master1 1
-
-sentinel monitor master2 127.0.0.1 6381 2
-sentinel down-after-milliseconds master2 5000
-sentinel failover-timeout master2 15000
-sentinel parallel-syncs master2 1

data/examples/sentinel/start

@@ -1,49 +0,0 @@
-#! /usr/bin/env ruby
-
-# This is a helper script used together with examples/sentinel.rb
-# It runs two Redis masters, two slaves for each of them, and two sentinels.
-# After 30 seconds, the first master dies.
-#
-# You don't need to run this script yourself. Rather, use examples/sentinel.rb.
-
-require "fileutils"
-
-$pids = []
-
-at_exit do
-  $pids.each do |pid|
-    begin
-      Process.kill(:INT, pid)
-    rescue Errno::ESRCH
-    end
-  end
-
-  Process.waitall
-end
-
-base = File.expand_path(File.dirname(__FILE__))
-
-# Masters
-$pids << spawn("redis-server --port 6380 --loglevel warning")
-$pids << spawn("redis-server --port 6381 --loglevel warning")
-
-# Slaves of Master 1
-$pids << spawn("redis-server --port 63800 --slaveof 127.0.0.1 6380 --loglevel warning")
-$pids << spawn("redis-server --port 63801 --slaveof 127.0.0.1 6380 --loglevel warning")
-
-# Slaves of Master 2
-$pids << spawn("redis-server --port 63810 --slaveof 127.0.0.1 6381 --loglevel warning")
-$pids << spawn("redis-server --port 63811 --slaveof 127.0.0.1 6381 --loglevel warning")
-
-FileUtils.cp(File.join(base, "sentinel.conf"), "tmp/sentinel1.conf")
-FileUtils.cp(File.join(base, "sentinel.conf"), "tmp/sentinel2.conf")
-
-# Sentinels
-$pids << spawn("redis-server tmp/sentinel1.conf --sentinel --port 26379")
-$pids << spawn("redis-server tmp/sentinel2.conf --sentinel --port 26380")
-
-sleep 30
-
-Process.kill(:KILL, $pids[0])
-
-Process.waitall

data/examples/sentinel.rb

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

data/examples/sets.rb

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

data/examples/unicorn/config.ru

@@ -1,3 +0,0 @@
-run lambda { |env|
-  [200, {"Content-Type" => "text/plain"}, [Redis.current.randomkey]]
-}

data/examples/unicorn/unicorn.rb

@@ -1,20 +0,0 @@
-require "redis"
-
-worker_processes 3
-
-# If you set the connection to Redis *before* forking,
-# you will cause forks to share a file descriptor.
-#
-# This causes a concurrency problem by which one fork
-# can read or write to the socket while others are
-# performing other operations.
-#
-# Most likely you'll be getting ProtocolError exceptions
-# mentioning a wrong initial byte in the reply.
-#
-# Thus we need to connect to Redis after forking the
-# worker processes.
-
-after_fork do |server, worker|
-  Redis.current.disconnect!
-end

data/redis.gemspec

@@ -1,44 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-$:.unshift File.expand_path("../lib", __FILE__)
-
-require "redis/version"
-
-Gem::Specification.new do |s|
-  s.name = "redis"
-
-  s.version = Redis::VERSION
-
-  s.homepage = "https://github.com/redis/redis-rb"
-
-  s.summary = "A Ruby client library for Redis"
-
-  s.description = <<-EOS
-    A Ruby client that tries to match Redis' API one-to-one, while still
-    providing an idiomatic interface. It features thread-safety,
-    client-side sharding, pipelining, and an obsession for performance.
-  EOS
-
-  s.license = "MIT"
-
-  s.authors = [
-    "Ezra Zygmuntowicz",
-    "Taylor Weibley",
-    "Matthew Clark",
-    "Brian McKinney",
-    "Salvatore Sanfilippo",
-    "Luca Guidi",
-    "Michel Martens",
-    "Damian Janowski",
-    "Pieter Noordhuis"
-  ]
-
-  s.email = ["redis-db@googlegroups.com"]
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-
-  s.add_development_dependency("rake", "<11.0.0")
-  s.add_development_dependency("test-unit", "3.1.5")
-end

data/test/bitpos_test.rb

@@ -1,69 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-
-unless defined?(Enumerator)
-  Enumerator = Enumerable::Enumerator
-end
-
-class TestBitpos < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def test_bitpos_empty_zero
-    target_version "2.9.11" do
-      r.del "foo"
-      assert_equal 0, r.bitpos("foo", 0)
-    end
-  end
-
-  def test_bitpos_empty_one
-    target_version "2.9.11" do
-      r.del "foo"
-      assert_equal -1, r.bitpos("foo", 1)
-    end
-  end
-
-  def test_bitpos_zero
-    target_version "2.9.11" do
-      r.set "foo", "\xff\xf0\x00"
-      assert_equal 12, r.bitpos("foo", 0)
-    end
-  end
-
-  def test_bitpos_one
-    target_version "2.9.11" do
-      r.set "foo", "\x00\x0f\x00"
-      assert_equal 12, r.bitpos("foo", 1)
-    end
-  end
-
-  def test_bitpos_zero_end_is_given
-    target_version "2.9.11" do
-      r.set "foo", "\xff\xff\xff"
-      assert_equal 24, r.bitpos("foo", 0)
-      assert_equal 24, r.bitpos("foo", 0, 0)
-      assert_equal -1, r.bitpos("foo", 0, 0, -1)
-    end
-  end
-
-  def test_bitpos_one_intervals
-    target_version "2.9.11" do
-      r.set "foo", "\x00\xff\x00"
-      assert_equal 8,  r.bitpos("foo", 1, 0, -1)
-      assert_equal 8,  r.bitpos("foo", 1, 1, -1)
-      assert_equal -1, r.bitpos("foo", 1, 2, -1)
-      assert_equal -1, r.bitpos("foo", 1, 2, 200)
-      assert_equal 8,  r.bitpos("foo", 1, 1, 1)
-    end
-  end
-
-  def test_bitpos_raise_exception_if_stop_not_start
-    target_version "2.9.11" do
-      assert_raises(ArgumentError) do
-        r.bitpos("foo", 0, nil, 2)
-      end
-    end
-  end
-
-end

data/test/blocking_commands_test.rb

@@ -1,42 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("helper", File.dirname(__FILE__))
-require "lint/blocking_commands"
-
-class TestBlockingCommands < Test::Unit::TestCase
-
-  include Helper::Client
-  include Lint::BlockingCommands
-
-  def assert_takes_longer_than_client_timeout
-    timeout = OPTIONS[:timeout]
-    delay = timeout * 2
-
-    mock(:delay => delay) do |r|
-      t1 = Time.now
-      yield(r)
-      t2 = Time.now
-
-      assert timeout == r.client.timeout
-      assert delay <= (t2 - t1)
-    end
-  end
-
-  def test_blpop_disable_client_timeout
-    assert_takes_longer_than_client_timeout do |r|
-      assert_equal ["foo", "0"], r.blpop("foo")
-    end
-  end
-
-  def test_brpop_disable_client_timeout
-    assert_takes_longer_than_client_timeout do |r|
-      assert_equal ["foo", "0"], r.brpop("foo")
-    end
-  end
-
-  def test_brpoplpush_disable_client_timeout
-    assert_takes_longer_than_client_timeout do |r|
-      assert_equal "0", r.brpoplpush("foo", "bar")
-    end
-  end
-end