redis 2.0.0.rc1 → 2.0.0.rc2

data/lib/redis.rb

@@ -1,7 +1,7 @@
 require 'socket'
 
 class Redis
-  VERSION = "2.0.0.rc1"
+  VERSION = "2.0.0.rc2"
 
   class ProtocolError < RuntimeError
     def initialize(reply_type)
@@ -146,11 +146,11 @@ class Redis
   end
 
   def blpop(key, timeout)
-    @client.call_blocking(:blpop, key, timeout)
+    @client.call_without_timeout(:blpop, key, timeout)
   end
 
   def brpop(key, timeout)
-    @client.call_blocking(:brpop, key, timeout)
+    @client.call_without_timeout(:brpop, key, timeout)
   end
 
   def rpoplpush(source, destination)
@@ -430,38 +430,30 @@ class Redis
     @client.call(:publish, channel, message)
   end
 
+  def subscribed?
+    @client.kind_of? SubscribedClient
+  end
+
   def unsubscribe(*channels)
-    if @client.kind_of?(SubscribedClient)
-      @client = @client.unsubscribe(*channels)
-    else
-      @client.call(:unsubscribe, *channels)
-    end
+    raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
+    @client.unsubscribe(*channels)
+  end
+
+  def punsubscribe(*channels)
+    raise RuntimeError, "Can't unsubscribe if not subscribed." unless subscribed?
+    @client.punsubscribe(*channels)
   end
 
   def subscribe(*channels, &block)
-    if @client.kind_of?(SubscribedClient)
-      @client.call(:subscribe, *channels)
-    else
-      begin
-        original, @client = @client, SubscribedClient.new(@client)
-        @client.subscribe(*channels, &block)
-      ensure
-        @client = original
-      end
-    end
+    subscription(:subscribe, channels, block)
   end
 
   def psubscribe(*channels, &block)
-    if @client.kind_of?(SubscribedClient)
-      @client.call(:psubscribe, *channels)
-    else
-      begin
-        original, @client = @client, SubscribedClient.new(@client)
-        @client.psubscribe(*channels, &block)
-      ensure
-        @client = original
-      end
-    end
+    subscription(:psubscribe, channels, block)
+  end
+
+  def id
+    @client.id
   end
 
   def method_missing(command, *args)
@@ -474,6 +466,17 @@ private
     value == 1
   end
 
+  def subscription(method, channels, block)
+    return @client.call(method, *channels) if subscribed?
+
+    begin
+      original, @client = @client, SubscribedClient.new(@client)
+      @client.send(method, *channels, &block)
+    ensure
+      @client = original
+    end
+  end
+
 end
 
 begin

data/lib/redis/client.rb

@@ -8,7 +8,8 @@ class Redis
     DOLLAR   = "$".freeze
     ASTERISK = "*".freeze
 
-    attr_accessor :db, :host, :port, :password, :timeout, :logger
+    attr_accessor :db, :host, :port, :password, :logger
+    attr :timeout
 
     def initialize(options = {})
       @host = options[:host] || "127.0.0.1"
@@ -28,28 +29,39 @@ class Redis
       @sock
     end
 
-    def call(name, *args)
-      ensure_connected do
-        process_and_read([[name, *args]]).first
+    def id
+      "redis://#{host}:#{port}/#{db}"
+    end
+
+    def call(*args)
+      process(args) do
+        read
       end
     end
 
-    def call_async(name, *args)
-      ensure_connected do
-        process([[name, *args]])
+    def call_loop(*args)
+      process(args) do
+        loop { yield(read) }
       end
     end
 
     def call_pipelined(commands)
-      ensure_connected do
-        process_and_read(commands)
+      process(*commands) do
+        Array.new(commands.size) { read }
       end
     end
 
-    def call_blocking(name, *args)
-      ensure_connected do
-        without_socket_timeout do
-          call(name, *args)
+    def call_without_timeout(*args)
+      without_socket_timeout do
+        call(*args)
+      end
+    end
+
+    def process(*commands)
+      logging(commands) do
+        ensure_connected do
+          @sock.write(join_commands(commands))
+          yield if block_given?
         end
       end
     end
@@ -59,17 +71,19 @@ class Redis
     end
 
     def disconnect
+      return unless connected?
+
       begin
         @sock.close
       rescue
       ensure
         @sock = nil
       end
-      true
     end
 
     def reconnect
-      disconnect && connect
+      disconnect
+      connect
     end
 
     def read
@@ -94,11 +108,13 @@ class Redis
     end
 
     def without_socket_timeout
-      begin
-        self.timeout = 0
-        yield
-      ensure
-        self.timeout = @timeout
+      ensure_connected do
+        begin
+          self.timeout = 0
+          yield
+        ensure
+          self.timeout = @timeout
+        end
       end
     end
 
@@ -127,27 +143,12 @@ class Redis
 
     COMMAND_DELIMITER = "\r\n"
 
-    def process(commands)
-      logging(commands) do
-        @sock.write(join_commands(commands))
-        yield if block_given?
-      end
-    end
-
     def join_commands(commands)
       commands.map do |command|
         build_command(*command).join(COMMAND_DELIMITER) + COMMAND_DELIMITER
       end.join(COMMAND_DELIMITER) + COMMAND_DELIMITER
     end
 
-    def process_and_read(commands)
-      process(commands) do
-        @mutex.synchronize do
-          Array.new(commands.size).map { read }
-        end
-      end
-    end
-
     if "".respond_to?(:bytesize)
       def string_size(string)
         string.to_s.bytesize
@@ -196,7 +197,7 @@ class Redis
     end
 
     def logging(commands)
-      return yield unless @logger
+      return yield unless @logger && @logger.debug?
 
       begin
         commands.each do |name, *args|

data/lib/redis/distributed.rb

@@ -16,12 +16,13 @@ class Redis
     attr_reader :ring
 
     def initialize(urls, options = {})
+      @tag = options.delete(:tag) || /^{(.+?)}/
       @default_options = options
       @ring = HashRing.new urls.map { |url| Redis.connect(options.merge(:url => url)) }
     end
 
     def node_for(key)
-      @ring.get_node(key.to_s)
+      @ring.get_node(key_tag(key) || key)
     end
 
     def nodes
@@ -34,7 +35,6 @@ class Redis
 
     def quit
       on_each_node :quit
-    rescue Errno::ECONNRESET
     end
 
     def select(db)
@@ -45,10 +45,6 @@ class Redis
       on_each_node :ping
     end
 
-    def quit
-      on_each_node :quit
-    end
-
     def flushall
       on_each_node :flushall
     end
@@ -74,11 +70,15 @@ class Redis
     end
 
     def rename(old_name, new_name)
-      raise CannotDistribute, :rename
+      ensure_same_node(:rename, old_name, new_name) do |node|
+        node.rename(old_name, new_name)
+      end
     end
 
     def renamenx(old_name, new_name)
-      raise CannotDistribute, :renamenx
+      ensure_same_node(:renamenx, old_name, new_name) do |node|
+        node.renamenx(old_name, new_name)
+      end
     end
 
     def dbsize
@@ -214,7 +214,9 @@ class Redis
     end
 
     def rpoplpush(source, destination)
-      raise CannotDistribute, :rpoplpush
+      ensure_same_node(:rpoplpush, source, destination) do |node|
+        node.rpoplpush(source, destination)
+      end
     end
 
     def blpop(key, timeout)
@@ -238,7 +240,9 @@ class Redis
     end
 
     def smove(source, destination, member)
-      raise CannotDistribute, :smove
+      ensure_same_node(:smove, source, destination, member) do |node|
+        node.smove(source, destination, member)
+      end
     end
 
     def scard(key)
@@ -250,27 +254,39 @@ class Redis
     end
 
     def sinter(*keys)
-      raise CannotDistribute, :sinter
+      ensure_same_node(:sinter, *keys) do |node|
+        node.sinter(*keys)
+      end
     end
 
     def sinterstore(destination, *keys)
-      raise CannotDistribute, :sinterstore
+      ensure_same_node(:sinterstore, destination, *keys) do |node|
+        node.sinterstore(destination, *keys)
+      end
     end
 
     def sunion(*keys)
-      raise CannotDistribute, :sunion
+      ensure_same_node(:sunion, *keys) do |node|
+        node.sunion(*keys)
+      end
     end
 
-    def sunionstore(*keys)
-      raise CannotDistribute, :sunionstore
+    def sunionstore(destination, *keys)
+      ensure_same_node(:sunionstore, destination, *keys) do |node|
+        node.sunionstore(destination, *keys)
+      end
     end
 
     def sdiff(*keys)
-      raise CannotDistribute, :sdiff
+      ensure_same_node(:sdiff, *keys) do |node|
+        node.sdiff(*keys)
+      end
     end
 
-    def sdiffstore(*keys)
-      raise CannotDistribute, :sdiffstore
+    def sdiffstore(destination, *keys)
+      ensure_same_node(:sdiffstore, destination, *keys) do |node|
+        node.sdiffstore(destination, *keys)
+      end
     end
 
     def smembers(key)
@@ -294,19 +310,11 @@ class Redis
     end
 
     def zrange(key, start, stop, with_scores = false)
-      if with_scores
-        node_for(key).zrange(key, start, stop, "WITHSCORES")
-      else
-        node_for(key).zrange(key, start, stop)
-      end
+      node_for(key).zrange(key, start, stop, with_scores)
     end
 
     def zrevrange(key, start, stop, with_scores = false)
-      if with_scores
-        node_for(key).zrevrange(key, start, stop, "WITHSCORES")
-      else
-        node_for(key).zrevrange(key, start, stop)
-      end
+      node_for(key).zrevrange(key, start, stop, with_scores)
     end
 
     def zrangebyscore(key, min, max)
@@ -358,7 +366,11 @@ class Redis
     end
 
     def sort(key, options = {})
-      raise CannotDistribute, :sort
+      keys = [key, options[:by], options[:store], *Array(options[:get])].compact
+
+      ensure_same_node(:sort, *keys) do |node|
+        node.sort(key, options)
+      end
     end
 
     def multi(&block)
@@ -432,5 +444,17 @@ class Redis
     def node_index_for(key)
       nodes.index(node_for(key))
     end
+
+    def key_tag(key)
+      key[@tag, 1] if @tag
+    end
+
+    def ensure_same_node(command, *keys)
+      tags = keys.map { |key| key_tag(key) }
+
+      raise CannotDistribute, command if tags.compact.uniq.size != 1
+
+      yield(node_for(keys.first))
+    end
   end
 end

data/lib/redis/hash_ring.rb

@@ -24,7 +24,7 @@ class Redis
     def add_node(node)
       @nodes << node
       @replicas.times do |i|
-        key = Zlib.crc32("#{node}:#{i}")
+        key = Zlib.crc32("#{node.id}:#{i}")
         @ring[key] = node
         @sorted_keys << key
       end
@@ -32,9 +32,9 @@ class Redis
     end
 
     def remove_node(node)
-      @nodes.reject!{|n| n.to_s == node.to_s}
+      @nodes.reject!{|n| n.id == node.id}
       @replicas.times do |i|
-        key = Zlib.crc32("#{node}:#{i}")
+        key = Zlib.crc32("#{node.id}:#{i}")
         @ring.delete(key)
         @sorted_keys.reject! {|k| k == key}
       end

data/lib/redis/subscribe.rb

@@ -4,51 +4,41 @@ class Redis
       @client = client
     end
 
-    def call(command, *args)
-      @client.call_async(command, *args)
+    def call(*args)
+      @client.process(args)
     end
 
     def subscribe(*channels, &block)
-      @client.call_async(:subscribe, *channels)
-
-      sub = Subscription.new(&block)
+      subscription("subscribe", "unsubscribe", channels, block)
+    end
 
-      begin
-        loop do
-          type, channel, message = @client.read
-          sub.callbacks[type].call(channel, message)
-          break if type == "unsubscribe" && message == 0
-        end
-      ensure
-        @client.call_async(:unsubscribe)
-      end
+    def psubscribe(*channels, &block)
+      subscription("psubscribe", "punsubscribe", channels, block)
     end
 
     def unsubscribe(*channels)
-      @client.call_async(:unsubscribe, *channels)
-      @client
+      call(:unsubscribe, *channels)
     end
 
-    def psubscribe(*channels, &block)
-      @client.call_async(:psubscribe, *channels)
+    def punsubscribe(*channels)
+      call(:punsubscribe, *channels)
+    end
+
+  protected
 
+    def subscription(start, stop, channels, block)
       sub = Subscription.new(&block)
 
       begin
-        loop do
-          type, pattern, channel, message = @client.read
-          sub.callbacks[type].call(pattern, channel, message)
-          break if type == "punsubscribe" && channel == 0
+        @client.call_loop(start, *channels) do |line|
+          type, *rest = line
+          sub.callbacks[type].call(*rest)
+          break if type == stop && rest.last == 0
         end
       ensure
-        @client.call_async(:punsubscribe)
+        send(stop)
       end
     end
-
-    def punsubscribe(*channels)
-      @client.call_async(:punsubscribe, *channels)
-      @client
-    end
   end
 
   class Subscription

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 2
   - 0
   - 0
-  - rc1
-  version: 2.0.0.rc1
+  - rc2
+  version: 2.0.0.rc2
 platform: ruby
 authors: 
 - Ezra Zygmuntowicz
@@ -20,7 +20,7 @@ autorequire: redis
 bindir: bin
 cert_chain: []
 
-date: 2010-04-26 00:00:00 -03:00
+date: 2010-04-28 00:00:00 -03:00
 default_executable: 
 dependencies: []