redis 1.0.2 → 1.0.3

data/Rakefile

@@ -12,7 +12,7 @@ GEM_VERSION = Redis::VERSION
 AUTHORS = ['Ezra Zygmuntowicz', 'Taylor Weibley', 'Matthew Clark', 'Brian McKinney', 'Salvatore Sanfilippo', 'Luca Guidi']
 EMAIL = "ez@engineyard.com"
 HOMEPAGE = "http://github.com/ezmobius/redis-rb"
-SUMMARY = "Ruby client library for redis key value storage server"
+SUMMARY = "Ruby client library for Redis, the key value storage server"
 
 spec = Gem::Specification.new do |s|
   s.name = GEM
@@ -25,7 +25,6 @@ spec = Gem::Specification.new do |s|
   s.authors = AUTHORS
   s.email = EMAIL
   s.homepage = HOMEPAGE
-  s.add_development_dependency "rspec"
   s.require_path = 'lib'
   s.autorequire = GEM
   s.files = %w(LICENSE README.markdown Rakefile) + Dir.glob("{lib,tasks,spec}/**/*")

data/lib/redis.rb

@@ -1,7 +1,7 @@
 require 'socket'
 
 class Redis
-  VERSION = "1.0.2"
+  VERSION = "1.0.3"
 
   def self.new(*attrs)
     Client.new(*attrs)

data/lib/redis/client.rb

@@ -1,5 +1,11 @@
 class Redis
   class Client
+    class ProtocolError < RuntimeError
+      def initialize(reply_type)
+        super("Protocol error, got '#{reply_type}' as initial reply byte")
+      end
+    end
+
     OK      = "OK".freeze
     MINUS    = "-".freeze
     PLUS     = "+".freeze
@@ -215,8 +221,8 @@ class Redis
     end
 
     def sort(key, options = {})
-      cmd = ["SORT"]
-      cmd << key
+      cmd = []
+      cmd << "SORT #{key}"
       cmd << "BY #{options[:by]}" if options[:by]
       cmd << "GET #{[options[:get]].flatten * ' GET '}" if options[:get]
       cmd << "#{options[:order]}" if options[:order]
@@ -226,11 +232,21 @@ class Redis
     end
 
     def incr(key, increment = nil)
-      call_command(increment ? ["incrby",key,increment] : ["incr",key])
+      if increment
+        deprecated("incr with an increment", :incrby, caller[0])
+        incrby(key, increment)
+      else
+        call_command([:incr, key])
+      end
     end
 
-    def decr(key,decrement = nil)
-      call_command(decrement ? ["decrby",key,decrement] : ["decr",key])
+    def decr(key, decrement = nil)
+      if decrement
+        deprecated("decr with a decrement", :decrby, caller[0])
+        decrby(key, decrement)
+      else
+        call_command([:decr, key])
+      end
     end
 
     # Ruby defines a now deprecated type method so we need to override it here
@@ -270,13 +286,13 @@ class Redis
     end
 
     def subscribe(*classes)
-      # Top-level `subscribe` MUST be called with a block,	
-      # nested `subscribe` MUST NOT be called with a block	
-      if !@pubsub && !block_given?	
+      # 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?	
+      elsif @pubsub == true && block_given?
         raise "Nested subscribe does not take a block"
-      elsif @pubsub	
+      elsif @pubsub
         # If we're already pubsub'ing, just subscribe us to some more classes
         call_command [:subscribe,*classes]
         return true
@@ -305,26 +321,21 @@ class Redis
       end
     end
 
-    def unsubscribe(*classes)
-      call_command [:unsubscribe,*classes]
-      return true
-    end
-
+    # Wrap raw_call_command to handle reconnection on socket error. We
+    # try to reconnect just one time, otherwise let the error araise.
     def call_command(argv)
       log(argv.inspect, :debug)
 
-      # this wrapper to raw_call_command handle reconnection on socket
-      # error. We try to reconnect just one time, otherwise let the error
-      # araise.
-      connect_to_server if !@sock
+      connect_to_server unless connected?
 
       begin
         raw_call_command(argv.dup)
       rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED
-        @sock.close rescue nil
-        @sock = nil
-        connect_to_server
-        raw_call_command(argv.dup)
+        if reconnect
+          raw_call_command(argv.dup)
+        else
+          raise Errno::ECONNRESET
+        end
       end
     end
 
@@ -332,35 +343,38 @@ class Redis
       "#{@host}:#{@port}"
     end
 
-    def connect_to(host, port, timeout=nil)
-      # We support connect() timeout only if system_timer is availabe
+    def connect_to(host, port)
+
+      # We support connect_to() timeout only if system_timer is availabe
       # or if we are running against Ruby >= 1.9
       # Timeout reading from the socket instead will be supported anyway.
       if @timeout != 0 and Timer
         begin
-          sock = TCPSocket.new(host, port)
+          @sock = TCPSocket.new(host, port)
         rescue Timeout::Error
           @sock = nil
           raise Timeout::Error, "Timeout connecting to the server"
         end
       else
-        sock = TCPSocket.new(host, port)
+        @sock = TCPSocket.new(host, port)
       end
-      sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+
+      @sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
 
       # If the timeout is set we set the low level socket options in order
       # to make sure a blocking read will return after the specified number
       # of seconds. This hack is from memcached ruby client.
-      if timeout
-        set_socket_timeout(sock, timeout)
-      end
-      sock
+      set_socket_timeout!(@timeout) if @timeout
+
+    rescue Errno::ECONNREFUSED
+      raise Errno::ECONNREFUSED, "Unable to connect to Redis on #{host}:#{port}"
     end
 
     def connect_to_server
-      @sock = connect_to(@host, @port, @timeout == 0 ? nil : @timeout)
-      call_command(["auth",@password]) if @password
-      call_command(["select",@db]) unless @db == 0
+      connect_to(@host, @port)
+      call_command([:auth, @password]) if @password
+      call_command([:select, @db]) if @db != 0
+      @sock
     end
 
     def method_missing(*argv)
@@ -412,10 +426,10 @@ class Redis
       # The normal command execution is reading and processing the reply.
       results = maybe_lock do
         begin
-          set_socket_timeout(@sock, 0) if requires_timeout_reset?(argvv[0][0].to_s)
+          set_socket_timeout!(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)
+          set_socket_timeout!(@timeout) if requires_timeout_reset?(argvv[0][0].to_s)
         end
       end
 
@@ -439,50 +453,33 @@ class Redis
     end
 
     def read_reply
+
       # We read the first byte using read() mainly because gets() is
       # immune to raw socket timeouts.
       begin
-        rtype = @sock.read(1)
+        reply_type = @sock.read(1)
       rescue Errno::EAGAIN
+
         # We want to make sure it reconnects on the next command after the
         # timeout. Otherwise the server may reply in the meantime leaving
         # the protocol in a desync status.
-        @sock = nil
+        disconnect
+
         raise Errno::EAGAIN, "Timeout reading from the socket"
       end
 
-      raise Errno::ECONNRESET,"Connection lost" if !rtype
-      line = @sock.gets
-      case rtype
-      when MINUS
-        raise MINUS + line.strip
-      when PLUS
-        line.strip
-      when COLON
-        line.to_i
-      when DOLLAR
-        bulklen = line.to_i
-        return nil if bulklen == -1
-        data = @sock.read(bulklen)
-        @sock.read(2) # CRLF
-        data
-      when ASTERISK
-        objects = line.to_i
-        return nil if bulklen == -1
-        res = []
-        objects.times {
-          res << read_reply
-        }
-        res
-      else
-        raise "Protocol error, got '#{rtype}' as initial reply byte"
-      end
+      raise Errno::ECONNRESET, "Connection lost" unless reply_type
+
+      format_reply(reply_type, @sock.gets)
     end
 
+
     def get_size(string)
       string.respond_to?(:bytesize) ? string.bytesize : string.size
     end
 
+  private
+
     def log(str, level = :info)
       @logger.send(level, str.to_s) if @logger
     end
@@ -494,19 +491,73 @@ class Redis
     def requires_timeout_reset?(command)
       BLOCKING_COMMANDS[command] && @timeout
     end
-    
-    def set_socket_timeout(sock, timeout)
+
+    def set_socket_timeout!(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
+        @sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
+        @sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
+      rescue Exception => e
         # Solaris, for one, does not like/support socket timeouts.
-        log("Unable to use raw socket timeouts: #{ex.class.name}: #{ex.message}")
+        log("Unable to use raw socket timeouts: #{e.class.name}: #{e.message}")
       end
     end
 
+    def connected?
+      !! @sock
+    end
+
+    def disconnect
+      begin
+        @sock.close
+      rescue
+      ensure
+        @sock = nil
+      end
+      true
+    end
+
+    def reconnect
+      disconnect && connect_to_server
+    end
+
+    def format_reply(reply_type, line)
+      case reply_type
+      when MINUS    then format_error_reply(line)
+      when PLUS     then format_status_reply(line)
+      when COLON    then format_integer_reply(line)
+      when DOLLAR   then format_bulk_reply(line)
+      when ASTERISK then format_multi_bulk_reply(line)
+      else raise ProtocolError.new(reply_type)
+      end
+    end
+
+    def format_error_reply(line)
+      raise "-" + line.strip
+    end
+
+    def format_status_reply(line)
+      line.strip
+    end
+
+    def format_integer_reply(line)
+      line.to_i
+    end
+
+    def format_bulk_reply(line)
+      bulklen = line.to_i
+      return if bulklen == -1
+      reply = @sock.read(bulklen)
+      @sock.read(2) # Discard CRLF.
+      reply
+    end
+
+    def format_multi_bulk_reply(line)
+      reply = []
+      line.to_i.times { reply << read_reply }
+      reply
+    end
   end
 end

data/lib/redis/subscribe.rb

@@ -1,14 +1,16 @@
-class Subscription	
-  def subscribe(&block)
-    if block_given? then @subscribe = block else @subscribe end
+class Redis
+  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
-
-  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
-  - 2
-  version: 1.0.2
+  - 3
+  version: 1.0.3
 platform: ruby
 authors: 
 - Ezra Zygmuntowicz
@@ -19,22 +19,11 @@ autorequire: redis
 bindir: bin
 cert_chain: []
 
-date: 2010-04-02 00:00:00 -07:00
+date: 2010-04-03 00:00:00 -07:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  version_requirements: *id001
-description: Ruby client library for redis key value storage server
+dependencies: []
+
+description: Ruby client library for Redis, the key value storage server
 email: ez@engineyard.com
 executables: []
 
@@ -84,6 +73,6 @@ rubyforge_project:
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: Ruby client library for redis key value storage server
+summary: Ruby client library for Redis, the key value storage server
 test_files: []