redis 1.0.0 → 1.0.1

data/lib/redis.rb

@@ -1,7 +1,7 @@
 require 'socket'
 
 class Redis
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 
   def self.new(*attrs)
     Client.new(*attrs)
@@ -22,3 +22,4 @@ end
 
 require 'redis/client'
 require 'redis/pipeline'
+require 'redis/subscribe'

data/lib/redis/client.rb

@@ -124,6 +124,11 @@ class Redis
       "sync"    => true
     }
 
+    BLOCKING_COMMANDS = {
+      "blpop" => true,
+      "brpop" => true
+    }
+
     def initialize(options = {})
       @host    =  options[:host]    || '127.0.0.1'
       @port    = (options[:port]    || 6379).to_i
@@ -265,29 +270,39 @@ class Redis
     end
 
     def subscribe(*classes)
-      # Sanity check, as our API is a bit tricky. You MUST call
-      # the top-level subscribe with a block, but you can NOT call
-      # the nested subscribe calls with a block, as all the messages
-      # are processed by the top level call.
-      if @pubsub == false and !block_given?
-        raise "You must pass a block to the top level subscribe call"
-      elsif @pubsub == true and block_given?
-        raise "Can't pass a block to nested subscribe calls"
-      elsif @pubsub == true
-        # This is a nested subscribe call without a block given.
-        # We just need to send the subscribe command and return asap.
+      # Top-level `subscribe` MUST be called with a block,	
+      # nested `subscribe` MUST NOT be called with a block	
+      if !@pubsub && !block_given?	
+        raise "Top-level subscribe requires a block"
+      elsif @pubsub == true && block_given?	
+        raise "Nested subscribe does not take a block"
+      elsif @pubsub	
+        # If we're already pubsub'ing, just subscribe us to some more classes
         call_command [:subscribe,*classes]
         return true
       end
+
       @pubsub = true
       call_command [:subscribe,*classes]
-      while true
-        r = read_reply
-        msg = {:type => r[0], :class => r[1], :data => r[2]}
-        yield(msg)
-        break if msg[:type] == "unsubscribe" and r[2] == 0
+      sub = Subscription.new
+      yield(sub)
+      begin
+        while true
+          type, *reply = read_reply # type, [class,data]
+          case type
+          when 'subscribe','unsubscribe'
+            sub.send(type) && sub.send(type).call(reply[0])
+          when 'message'
+            sub.send(type) && sub.send(type).call(reply[0],reply[1])
+          end
+          break if type == 'unsubscribe' && reply[1] == 0
+        end
+      rescue RuntimeError
+        call_command [:unsubscribe]
+        raise
+      ensure
+        @pubsub = false
       end
-      @pubsub = false
     end
 
     def unsubscribe(*classes)
@@ -295,8 +310,6 @@ class Redis
       return true
     end
 
-  protected
-
     def call_command(argv)
       log(argv.inspect, :debug)
 
@@ -339,16 +352,7 @@ class Redis
       # to make sure a blocking read will return after the specified number
       # of seconds. This hack is from memcached ruby client.
       if timeout
-        secs   = Integer(timeout)
-        usecs  = Integer((timeout - secs) * 1_000_000)
-        optval = [secs, usecs].pack("l_2")
-        begin
-          sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
-          sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
-        rescue Exception => ex
-          # Solaris, for one, does not like/support socket timeouts.
-          log("Unable to use raw socket timeouts: #{ex.class.name}: #{ex.message}")
-        end
+        set_socket_timeout(sock, timeout)
       end
       sock
     end
@@ -406,7 +410,15 @@ class Redis
         return true
       end
       # The normal command execution is reading and processing the reply.
-      results = maybe_lock { process_command(command, argvv) }
+      results = maybe_lock do
+        begin
+          set_socket_timeout(@sock, 0) if requires_timeout_reset?(argvv[0][0].to_s)
+          process_command(command, argvv)
+        ensure
+          set_socket_timeout(@sock, @timeout) if requires_timeout_reset?(argvv[0][0].to_s)
+        end
+      end
+
       return pipeline ? results : results[0]
     end
 
@@ -478,5 +490,23 @@ class Redis
     def deprecated(old, new, trace = caller[0])
       $stderr.puts "\nRedis: The method #{old} is deprecated. Use #{new} instead (in #{trace})"
     end
+
+    def requires_timeout_reset?(command)
+      BLOCKING_COMMANDS[command] && @timeout
+    end
+    
+    def set_socket_timeout(sock, timeout)
+      secs   = Integer(timeout)
+      usecs  = Integer((timeout - secs) * 1_000_000)
+      optval = [secs, usecs].pack("l_2")
+      begin
+        sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
+        sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
+      rescue Exception => ex
+        # Solaris, for one, does not like/support socket timeouts.
+        log("Unable to use raw socket timeouts: #{ex.class.name}: #{ex.message}")
+      end
+    end
+
   end
 end

data/lib/redis/subscribe.rb

@@ -0,0 +1,14 @@
+class Subscription	
+  def subscribe(&block)
+    if block_given? then @subscribe = block else @subscribe end
+  end
+
+  def unsubscribe(&block)	
+    if block_given? then @unsubscribe = block else @unsubscribe end
+  end
+
+  def message(&block)	
+    if block_given? then @message = block else @message end
+  end
+	
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 1
   - 0
-  - 0
-  version: 1.0.0
+  - 1
+  version: 1.0.1
 platform: ruby
 authors: 
 - Ezra Zygmuntowicz
@@ -52,6 +52,7 @@ files:
 - lib/redis/hash_ring.rb
 - lib/redis/pipeline.rb
 - lib/redis/raketasks.rb
+- lib/redis/subscribe.rb
 - lib/redis.rb
 - tasks/redis.tasks.rb
 has_rdoc: true