redis 4.0.0.rc1 → 4.4.0

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/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/makefile

@@ -1,42 +0,0 @@
-TEST_FILES   := $(shell find test -name *_test.rb -type f)
-REDIS_BRANCH := unstable
-TMP          := tmp
-BUILD_DIR    := ${TMP}/redis-${REDIS_BRANCH}
-TARBALL      := ${TMP}/redis-${REDIS_BRANCH}.tar.gz
-BINARY       := ${BUILD_DIR}/src/redis-server
-PID_PATH     := ${BUILD_DIR}/redis.pid
-SOCKET_PATH  := ${BUILD_DIR}/redis.sock
-PORT         := 6381
-
-test: ${TEST_FILES}
-	make start
-	env SOCKET_PATH=${SOCKET_PATH} \
-		ruby -v $$(echo $? | tr ' ' '\n' | awk '{ print "-r./" $$0 }') -e ''
-	make stop
-
-${TMP}:
-	mkdir $@
-
-${TARBALL}: ${TMP}
-	wget https://github.com/antirez/redis/archive/${REDIS_BRANCH}.tar.gz -O $@
-
-${BINARY}: ${TARBALL} ${TMP}
-	rm -rf ${BUILD_DIR}
-	mkdir -p ${BUILD_DIR}
-	tar xf ${TARBALL} -C ${TMP}
-	cd ${BUILD_DIR} && make
-
-stop:
-	(test -f ${PID_PATH} && (kill $$(cat ${PID_PATH}) || true) && rm -f ${PID_PATH}) || true
-
-start: ${BINARY}
-	${BINARY}                     \
-		--daemonize  yes            \
-		--pidfile    ${PID_PATH}    \
-		--port       ${PORT}        \
-		--unixsocket ${SOCKET_PATH}
-
-clean:
-	(test -d ${BUILD_DIR} && cd ${BUILD_DIR}/src && make clean distclean) || true
-
-.PHONY: test start stop

data/redis.gemspec

@@ -1,40 +0,0 @@
-require "./lib/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.
-  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("test-unit", "3.1.5")
-  s.add_development_dependency("hiredis")
-  s.add_development_dependency("em-synchrony")
-end

data/test/bitpos_test.rb

@@ -1,63 +0,0 @@
-require_relative "helper"
-
-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,183 +0,0 @@
-require_relative "helper"
-
-class TestBlockingCommands < Test::Unit::TestCase
-
-  include Helper::Client
-
-  def setup
-    super
-
-    r.rpush("{zap}foo", "s1")
-    r.rpush("{zap}foo", "s2")
-    r.rpush("{zap}bar", "s1")
-    r.rpush("{zap}bar", "s2")
-  end
-
-  def to_protocol(obj)
-    case obj
-    when String
-      "$#{obj.length}\r\n#{obj}\r\n"
-    when Array
-      "*#{obj.length}\r\n" + obj.map { |e| to_protocol(e) }.join
-    else
-      fail
-    end
-  end
-
-  def mock(options = {}, &blk)
-    commands = {
-      :blpop => lambda do |*args|
-        sleep options[:delay] if options.has_key?(:delay)
-        to_protocol([args.first, args.last])
-      end,
-      :brpop => lambda do |*args|
-        sleep options[:delay] if options.has_key?(:delay)
-        to_protocol([args.first, args.last])
-      end,
-      :brpoplpush => lambda do |*args|
-        sleep options[:delay] if options.has_key?(:delay)
-        to_protocol(args.last)
-      end
-    }
-
-    redis_mock(commands, &blk)
-  end
-
-  def test_blpop
-    assert_equal ["{zap}foo", "s1"], r.blpop("{zap}foo")
-    assert_equal ["{zap}foo", "s2"], r.blpop(["{zap}foo"])
-    assert_equal ["{zap}bar", "s1"], r.blpop(["{zap}bar", "{zap}foo"])
-    assert_equal ["{zap}bar", "s2"], r.blpop(["{zap}foo", "{zap}bar"])
-  end
-
-  def test_blpop_timeout
-    mock do |r|
-      assert_equal ["{zap}foo", "0"], r.blpop("{zap}foo")
-      assert_equal ["{zap}foo", "1"], r.blpop("{zap}foo", :timeout => 1)
-    end
-  end
-
-  def test_blpop_with_old_prototype
-    assert_equal ["{zap}foo", "s1"], r.blpop("{zap}foo", 0)
-    assert_equal ["{zap}foo", "s2"], r.blpop("{zap}foo", 0)
-    assert_equal ["{zap}bar", "s1"], r.blpop("{zap}bar", "{zap}foo", 0)
-    assert_equal ["{zap}bar", "s2"], r.blpop("{zap}foo", "{zap}bar", 0)
-  end
-
-  def test_blpop_timeout_with_old_prototype
-    mock do |r|
-      assert_equal ["{zap}foo", "0"], r.blpop("{zap}foo", 0)
-      assert_equal ["{zap}foo", "1"], r.blpop("{zap}foo", 1)
-    end
-  end
-
-  def test_brpop
-    assert_equal ["{zap}foo", "s2"], r.brpop("{zap}foo")
-    assert_equal ["{zap}foo", "s1"], r.brpop(["{zap}foo"])
-    assert_equal ["{zap}bar", "s2"], r.brpop(["{zap}bar", "{zap}foo"])
-    assert_equal ["{zap}bar", "s1"], r.brpop(["{zap}foo", "{zap}bar"])
-  end
-
-  def test_brpop_timeout
-    mock do |r|
-      assert_equal ["{zap}foo", "0"], r.brpop("{zap}foo")
-      assert_equal ["{zap}foo", "1"], r.brpop("{zap}foo", :timeout => 1)
-    end
-  end
-
-  def test_brpop_with_old_prototype
-    assert_equal ["{zap}foo", "s2"], r.brpop("{zap}foo", 0)
-    assert_equal ["{zap}foo", "s1"], r.brpop("{zap}foo", 0)
-    assert_equal ["{zap}bar", "s2"], r.brpop("{zap}bar", "{zap}foo", 0)
-    assert_equal ["{zap}bar", "s1"], r.brpop("{zap}foo", "{zap}bar", 0)
-  end
-
-  def test_brpop_timeout_with_old_prototype
-    mock do |r|
-      assert_equal ["{zap}foo", "0"], r.brpop("{zap}foo", 0)
-      assert_equal ["{zap}foo", "1"], r.brpop("{zap}foo", 1)
-    end
-  end
-
-  def test_brpoplpush
-    assert_equal "s2", r.brpoplpush("{zap}foo", "{zap}qux")
-    assert_equal ["s2"], r.lrange("{zap}qux", 0, -1)
-  end
-
-  def test_brpoplpush_timeout
-    mock do |r|
-      assert_equal "0", r.brpoplpush("{zap}foo", "{zap}bar")
-      assert_equal "1", r.brpoplpush("{zap}foo", "{zap}bar", :timeout => 1)
-    end
-  end
-
-  def test_brpoplpush_with_old_prototype
-    assert_equal "s2", r.brpoplpush("{zap}foo", "{zap}qux", 0)
-    assert_equal ["s2"], r.lrange("{zap}qux", 0, -1)
-  end
-
-  def test_brpoplpush_timeout_with_old_prototype
-    mock do |r|
-      assert_equal "0", r.brpoplpush("{zap}foo", "{zap}bar", 0)
-      assert_equal "1", r.brpoplpush("{zap}foo", "{zap}bar", 1)
-    end
-  end
-
-  driver(:ruby, :hiredis) do
-    def test_blpop_socket_timeout
-      mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r|
-        assert_raises(Redis::TimeoutError) do
-          r.blpop("{zap}foo", :timeout => 1)
-        end
-      end
-    end
-
-    def test_brpop_socket_timeout
-      mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r|
-        assert_raises(Redis::TimeoutError) do
-          r.brpop("{zap}foo", :timeout => 1)
-        end
-      end
-    end
-
-    def test_brpoplpush_socket_timeout
-      mock(:delay => 1 + OPTIONS[:timeout] * 2) do |r|
-        assert_raises(Redis::TimeoutError) do
-          r.brpoplpush("{zap}foo", "{zap}bar", :timeout => 1)
-        end
-      end
-    end
-  end
-
-  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