discourse-redis 3.2.2

data/lib/redis/errors.rb

@@ -0,0 +1,40 @@
+class Redis
+  # Base error for all redis-rb errors.
+  class BaseError < RuntimeError
+  end
+
+  # Raised by the connection when a protocol error occurs.
+  class ProtocolError < BaseError
+    def initialize(reply_type)
+      super(<<-EOS.gsub(/(?:^|\n)\s*/, " "))
+        Got '#{reply_type}' as initial reply byte.
+        If you're in a forking environment, such as Unicorn, you need to
+        connect to Redis after forking.
+      EOS
+    end
+  end
+
+  # Raised by the client when command execution returns an error reply.
+  class CommandError < BaseError
+  end
+
+  # Base error for connection related errors.
+  class BaseConnectionError < BaseError
+  end
+
+  # Raised when connection to a Redis server cannot be made.
+  class CannotConnectError < BaseConnectionError
+  end
+
+  # Raised when connection to a Redis server is lost.
+  class ConnectionError < BaseConnectionError
+  end
+
+  # Raised when performing I/O times out.
+  class TimeoutError < BaseConnectionError
+  end
+
+  # Raised when the connection was inherited by a child process.
+  class InheritedError < BaseConnectionError
+  end
+end

data/lib/redis/hash_ring.rb

@@ -0,0 +1,132 @@
+require 'zlib'
+
+class Redis
+  class HashRing
+
+    POINTS_PER_SERVER = 160 # this is the default in libmemcached
+
+    attr_reader :ring, :sorted_keys, :replicas, :nodes
+
+    # nodes is a list of objects that have a proper to_s representation.
+    # replicas indicates how many virtual points should be used pr. node,
+    # replicas are required to improve the distribution.
+    def initialize(nodes=[], replicas=POINTS_PER_SERVER)
+      @replicas = replicas
+      @ring = {}
+      @nodes = []
+      @sorted_keys = []
+      nodes.each do |node|
+        add_node(node)
+      end
+    end
+
+    # Adds a `node` to the hash ring (including a number of replicas).
+    def add_node(node)
+      @nodes << node
+      @replicas.times do |i|
+        key = Zlib.crc32("#{node.id}:#{i}")
+        raise "Node ID collision" if @ring.has_key?(key)
+        @ring[key] = node
+        @sorted_keys << key
+      end
+      @sorted_keys.sort!
+    end
+
+    def remove_node(node)
+      @nodes.reject!{|n| n.id == node.id}
+      @replicas.times do |i|
+        key = Zlib.crc32("#{node.id}:#{i}")
+        @ring.delete(key)
+        @sorted_keys.reject! {|k| k == key}
+      end
+    end
+
+    # get the node in the hash ring for this key
+    def get_node(key)
+      get_node_pos(key)[0]
+    end
+
+    def get_node_pos(key)
+      return [nil,nil] if @ring.size == 0
+      crc = Zlib.crc32(key)
+      idx = HashRing.binary_search(@sorted_keys, crc)
+      return [@ring[@sorted_keys[idx]], idx]
+    end
+
+    def iter_nodes(key)
+      return [nil,nil] if @ring.size == 0
+      _, pos = get_node_pos(key)
+      @ring.size.times do |n|
+        yield @ring[@sorted_keys[(pos+n) % @ring.size]]
+      end
+    end
+
+    class << self
+
+      # gem install RubyInline to use this code
+      # Native extension to perform the binary search within the hashring.
+      # There's a pure ruby version below so this is purely optional
+      # for performance.  In testing 20k gets and sets, the native
+      # binary search shaved about 12% off the runtime (9sec -> 8sec).
+      begin
+        require 'inline'
+        inline do |builder|
+          builder.c <<-EOM
+          int binary_search(VALUE ary, unsigned int r) {
+              int upper = RARRAY_LEN(ary) - 1;
+              int lower = 0;
+              int idx = 0;
+
+              while (lower <= upper) {
+                  idx = (lower + upper) / 2;
+
+                  VALUE continuumValue = RARRAY_PTR(ary)[idx];
+                  unsigned int l = NUM2UINT(continuumValue);
+                  if (l == r) {
+                      return idx;
+                  }
+                  else if (l > r) {
+                      upper = idx - 1;
+                  }
+                  else {
+                      lower = idx + 1;
+                  }
+              }
+              if (upper < 0) {
+                upper = RARRAY_LEN(ary) - 1;
+              }
+              return upper;
+          }
+          EOM
+        end
+      rescue Exception
+        # Find the closest index in HashRing with value <= the given value
+        def binary_search(ary, value, &block)
+          upper = ary.size - 1
+          lower = 0
+          idx = 0
+
+          while(lower <= upper) do
+            idx = (lower + upper) / 2
+            comp = ary[idx] <=> value
+
+            if comp == 0
+              return idx
+            elsif comp > 0
+              upper = idx - 1
+            else
+              lower = idx + 1
+            end
+          end
+
+          if upper < 0
+            upper = ary.size - 1
+          end
+          return upper
+        end
+
+      end
+    end
+
+  end
+end

data/lib/redis/pipeline.rb

@@ -0,0 +1,141 @@
+class Redis
+  unless defined?(::BasicObject)
+    class BasicObject
+      instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A(__|instance_eval)/ }
+    end
+  end
+
+  class Pipeline
+    attr_accessor :db
+
+    attr :futures
+
+    def initialize
+      @with_reconnect = true
+      @shutdown = false
+      @futures = []
+    end
+
+    def with_reconnect?
+      @with_reconnect
+    end
+
+    def without_reconnect?
+      !@with_reconnect
+    end
+
+    def shutdown?
+      @shutdown
+    end
+
+    def call(command, &block)
+      # A pipeline that contains a shutdown should not raise ECONNRESET when
+      # the connection is gone.
+      @shutdown = true if command.first == :shutdown
+      future = Future.new(command, block)
+      @futures << future
+      future
+    end
+
+    def call_pipeline(pipeline)
+      @shutdown = true if pipeline.shutdown?
+      @futures.concat(pipeline.futures)
+      @db = pipeline.db
+      nil
+    end
+
+    def commands
+      @futures.map { |f| f._command }
+    end
+
+    def with_reconnect(val=true)
+      @with_reconnect = false unless val
+      yield
+    end
+
+    def without_reconnect(&blk)
+      with_reconnect(false, &blk)
+    end
+
+    def finish(replies, &blk)
+      if blk
+        futures.each_with_index.map do |future, i|
+          future._set(blk.call(replies[i]))
+        end
+      else
+        futures.each_with_index.map do |future, i|
+          future._set(replies[i])
+        end
+      end
+    end
+
+    class Multi < self
+      def finish(replies)
+        exec = replies.last
+
+        return if exec.nil? # The transaction failed because of WATCH.
+
+        # EXEC command failed.
+        raise exec if exec.is_a?(CommandError)
+
+        if exec.size < futures.size
+          # Some command wasn't recognized by Redis.
+          raise replies.detect { |r| r.is_a?(CommandError) }
+        end
+
+        super(exec) do |reply|
+          # Because an EXEC returns nested replies, hiredis won't be able to
+          # convert an error reply to a CommandError instance itself. This is
+          # specific to MULTI/EXEC, so we solve this here.
+          reply.is_a?(::RuntimeError) ? CommandError.new(reply.message) : reply
+        end
+      end
+
+      def commands
+        [[:multi]] + super + [[:exec]]
+      end
+    end
+  end
+
+  class FutureNotReady < RuntimeError
+    def initialize
+      super("Value will be available once the pipeline executes.")
+    end
+  end
+
+  class Future < BasicObject
+    FutureNotReady = ::Redis::FutureNotReady.new
+
+    def initialize(command, transformation)
+      @command = command
+      @transformation = transformation
+      @object = FutureNotReady
+    end
+
+    def inspect
+      "<Redis::Future #{@command.inspect}>"
+    end
+
+    def _set(object)
+      @object = @transformation ? @transformation.call(object) : object
+      value
+    end
+
+    def _command
+      @command
+    end
+
+    def value
+      ::Kernel.raise(@object) if @object.kind_of?(::RuntimeError)
+      @object
+    end
+
+    def is_a?(other)
+      self.class.ancestors.include?(other)
+    end
+
+    def class
+      Future
+    end
+  end
+end

data/lib/redis/subscribe.rb

@@ -0,0 +1,83 @@
+class Redis
+  class SubscribedClient
+    def initialize(client)
+      @client = client
+    end
+
+    def call(command)
+      @client.process([command])
+    end
+
+    def subscribe(*channels, &block)
+      subscription("subscribe", "unsubscribe", channels, block)
+    end
+
+    def psubscribe(*channels, &block)
+      subscription("psubscribe", "punsubscribe", channels, block)
+    end
+
+    def unsubscribe(*channels)
+      call([:unsubscribe, *channels])
+    end
+
+    def punsubscribe(*channels)
+      call([:punsubscribe, *channels])
+    end
+
+  protected
+
+    def subscription(start, stop, channels, block)
+      sub = Subscription.new(&block)
+
+      unsubscribed = false
+
+      begin
+        @client.call_loop([start, *channels]) do |line|
+          type, *rest = line
+          sub.callbacks[type].call(*rest)
+          unsubscribed = type == stop && rest.last == 0
+          break if unsubscribed
+        end
+      ensure
+        # No need to unsubscribe here. The real client closes the connection
+        # whenever an exception is raised (see #ensure_connected).
+      end
+    end
+  end
+
+  class Subscription
+    attr :callbacks
+
+    def initialize
+      @callbacks = Hash.new do |hash, key|
+        hash[key] = lambda { |*_| }
+      end
+
+      yield(self)
+    end
+
+    def subscribe(&block)
+      @callbacks["subscribe"] = block
+    end
+
+    def unsubscribe(&block)
+      @callbacks["unsubscribe"] = block
+    end
+
+    def message(&block)
+      @callbacks["message"] = block
+    end
+
+    def psubscribe(&block)
+      @callbacks["psubscribe"] = block
+    end
+
+    def punsubscribe(&block)
+      @callbacks["punsubscribe"] = block
+    end
+
+    def pmessage(&block)
+      @callbacks["pmessage"] = block
+    end
+  end
+end

data/lib/redis/version.rb

@@ -0,0 +1,3 @@
+class Redis
+  VERSION = "3.2.2"
+end

data/redis.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+$:.unshift File.expand_path("../lib", __FILE__)
+
+require "redis/version"
+
+Gem::Specification.new do |s|
+  s.name = "discourse-redis"
+
+  s.version = Redis::VERSION
+
+  s.homepage = "https://github.com/discourse/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 = ["Alan Tan Guo Xiang"]
+
+  s.email = ["tgx_world@hotmail.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")
+  s.add_development_dependency("test-unit")
+end

data/test/bitpos_test.rb

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