redis 4.0.3 → 4.5.0

data/bin/build

@@ -1,71 +0,0 @@
-#!/usr/bin/env ruby
-
-TARBALL = ARGV[0]
-
-require 'digest/sha1'
-require 'fileutils'
-
-class Builder
-  def initialize(redis_branch, tmp_dir)
-    @redis_branch = redis_branch
-    @tmp_dir = tmp_dir
-    @build_dir = File.join(@tmp_dir, "cache", "redis-#{redis_branch}")
-  end
-
-  def run
-    download_tarball
-    if old_checkum != checksum
-      build
-      update_checksum
-    end
-    0
-  end
-
-  def download_tarball
-    command!('wget', tarball_url, '-O', tarball_path)
-  end
-
-  def tarball_path
-    File.join(@tmp_dir, "redis-#{@redis_branch}.tar.gz")
-  end
-
-  def tarball_url
-    "https://github.com/antirez/redis/archive/#{@redis_branch}.tar.gz"
-  end
-
-  def build
-    FileUtils.rm_rf(@build_dir)
-    FileUtils.mkdir_p(@build_dir)
-    command!('tar', 'xf', tarball_path, '-C', File.expand_path('../', @build_dir))
-    Dir.chdir(@build_dir) do
-      command!('make')
-    end
-  end
-
-  def update_checksum
-    File.write(checksum_path, checksum)
-  end
-
-  def old_checkum
-    File.read(checksum_path)
-  rescue Errno::ENOENT
-    nil
-  end
-
-  def checksum_path
-    File.join(@build_dir, 'build.checksum')
-  end
-
-  def checksum
-    @checksum ||= Digest::SHA1.file(tarball_path).hexdigest
-  end
-
-  def command!(*args)
-    puts "$ #{args.join(' ')}"
-    unless system(*args)
-      raise "Command failed with status #{$?.exitstatus}"
-    end
-  end
-end
-
-exit Builder.new(ARGV[0], ARGV[1]).run

data/bors.toml

@@ -1,14 +0,0 @@
-# Gate on Travis CI
-status = ["continuous-integration/travis-ci/push"]
-
-# Set bors's timeout to 6 hours
-#
-# bors's timeout should always be twice a long as the test suite takes.
-# This is to allow Travis to fast-fail a test; if one of the builders
-# immediately reports a failure, then bors will move on to the next batch,
-# leaving the slower builders to work through the already-doomed run and
-# the next one.
-#
-# At the time it was written, a run had taken 3 hours.
-# bors's default timeout is 4 hours.
-timeout_sec = 14400

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

@@ -1,74 +0,0 @@
-TEST_FILES         := $(shell find ./test -name *_test.rb -type f)
-REDIS_BRANCH       ?= unstable
-TMP                := tmp
-BUILD_DIR          := ${TMP}/cache/redis-${REDIS_BRANCH}
-TARBALL            := ${TMP}/redis-${REDIS_BRANCH}.tar.gz
-BINARY             := ${BUILD_DIR}/src/redis-server
-REDIS_CLIENT       := ${BUILD_DIR}/src/redis-cli
-REDIS_TRIB         := ${BUILD_DIR}/src/redis-trib.rb
-PID_PATH           := ${BUILD_DIR}/redis.pid
-SOCKET_PATH        := ${BUILD_DIR}/redis.sock
-PORT               := 6381
-CLUSTER_PORTS      := 7000 7001 7002 7003 7004 7005
-CLUSTER_PID_PATHS  := $(addprefix ${TMP}/redis,$(addsuffix .pid,${CLUSTER_PORTS}))
-CLUSTER_CONF_PATHS := $(addprefix ${TMP}/nodes,$(addsuffix .conf,${CLUSTER_PORTS}))
-CLUSTER_ADDRS      := $(addprefix 127.0.0.1:,${CLUSTER_PORTS})
-
-define kill-redis
-  (ls $1 2> /dev/null && kill $$(cat $1) && rm -f $1) || true
-endef
-
-all:
-	make start
-	make start_cluster
-	make create_cluster
-	make test
-	make stop
-	make stop_cluster
-
-${TMP}:
-	mkdir -p $@
-
-${BINARY}: ${TMP}
-	bin/build ${REDIS_BRANCH} $<
-
-test: ${TEST_FILES}
-	env SOCKET_PATH=${SOCKET_PATH} \
-		bundle exec ruby -v -e 'ARGV.each { |test_file| require test_file }' ${TEST_FILES}
-
-stop:
-	$(call kill-redis,${PID_PATH})
-
-start: ${BINARY}
-	${BINARY}                     \
-		--daemonize  yes            \
-		--pidfile    ${PID_PATH}    \
-		--port       ${PORT}        \
-		--unixsocket ${SOCKET_PATH}
-
-stop_cluster:
-	$(call kill-redis,${CLUSTER_PID_PATHS})
-	rm -f appendonly.aof || true
-	rm -f ${CLUSTER_CONF_PATHS} || true
-
-start_cluster: ${BINARY}
-	for port in ${CLUSTER_PORTS}; do                    \
-		${BINARY}                                         \
-			--daemonize            yes                      \
-			--appendonly           yes                      \
-			--cluster-enabled      yes                      \
-			--cluster-config-file  ${TMP}/nodes$$port.conf  \
-			--cluster-node-timeout 5000                     \
-			--pidfile              ${TMP}/redis$$port.pid   \
-			--port                 $$port                   \
-			--unixsocket           ${TMP}/redis$$port.sock; \
-	done
-
-create_cluster:
-	yes yes | ((bundle exec ruby ${REDIS_TRIB} create --replicas 1 ${CLUSTER_ADDRS}) || \
-		(${REDIS_CLIENT} --cluster create ${CLUSTER_ADDRS} --cluster-replicas 1))
-
-clean:
-	(test -d ${BUILD_DIR} && cd ${BUILD_DIR}/src && make clean distclean) || true
-
-.PHONY: all test stop start stop_cluster start_cluster create_cluster clean

data/redis.gemspec

@@ -1,43 +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 -- exe/*`.split("\n").map{ |f| File.basename(f) }
-
-  s.required_ruby_version = '>= 2.2.2'
-
-  s.add_development_dependency("test-unit", ">= 3.1.5")
-  s.add_development_dependency("mocha")
-  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