redis 2.0.13 → 2.1.0.beta

data/README.markdown

@@ -111,6 +111,15 @@ You can use `MULTI/EXEC` to run arbitrary commands in an atomic fashion:
       redis.incr "baz"
     end
 
+## Multithreaded Operation
+
+To use redis safely in a multithreaded environment, be sure to initialize the client with :thread_safe=>true
+
+    Redis.new(:thread_safe=>true)
+
+See the tests and benchmarks for examples.
+
+
 ## More info
 
 Check the [Redis Command Reference](http://code.google.com/p/redis/wiki/CommandReference) or check the tests to find out how to use this client.

data/lib/redis.rb

@@ -1,7 +1,7 @@
 require 'socket'
 
 class Redis
-  VERSION = "2.0.13"
+  VERSION = "2.1.0.beta"
 
   class ProtocolError < RuntimeError
     def initialize(reply_type)
@@ -669,7 +669,8 @@ private
 
 end
 
-require 'redis/client'
-require 'redis/pipeline'
-require 'redis/subscribe'
-require 'redis/compat'
+require "redis/connection" unless defined?(Redis::Connection)
+require "redis/client"
+require "redis/pipeline"
+require "redis/subscribe"
+require "redis/compat"

data/lib/redis/client.rb

@@ -1,13 +1,8 @@
 class Redis
   class Client
-    MINUS    = "-".freeze
-    PLUS     = "+".freeze
-    COLON    = ":".freeze
-    DOLLAR   = "$".freeze
-    ASTERISK = "*".freeze
-
     attr_accessor :db, :host, :port, :password, :logger
     attr :timeout
+    attr :connection
 
     def initialize(options = {})
       @host = options[:host] || "127.0.0.1"
@@ -16,14 +11,14 @@ class Redis
       @timeout = (options[:timeout] || 5).to_i
       @password = options[:password]
       @logger = options[:logger]
-      @sock = nil
+      @connection = Connection.new
     end
 
     def connect
       connect_to(@host, @port)
       call(:auth, @password) if @password
       call(:select, @db) if @db != 0
-      @sock
+      self
     end
 
     def id
@@ -61,25 +56,21 @@ class Redis
     def process(*commands)
       logging(commands) do
         ensure_connected do
-          @sock.write(join_commands(commands))
+          commands.each do |command|
+            connection.write(command)
+          end
+
           yield if block_given?
         end
       end
     end
 
     def connected?
-      !! @sock
+      connection.connected?
     end
 
     def disconnect
-      return unless connected?
-
-      begin
-        @sock.close
-      rescue
-      ensure
-        @sock = nil
-      end
+      connection.disconnect if connection.connected?
     end
 
     def reconnect
@@ -88,23 +79,20 @@ class Redis
     end
 
     def read
-      # We read the first byte using read() mainly because gets() is
-      # immune to raw socket timeouts.
       begin
-        reply_type = @sock.read(1)
-      rescue Errno::EAGAIN
+        connection.read
 
+      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.
-        disconnect
+        connection.disconnect
 
         raise Errno::EAGAIN, "Timeout reading from the socket"
-      end
-
-      raise Errno::ECONNRESET, "Connection lost" unless reply_type
 
-      format_reply(reply_type, @sock.gets)
+      rescue Errno::ECONNRESET
+        raise Errno::ECONNRESET, "Connection lost"
+      end
     end
 
     def without_socket_timeout
@@ -120,83 +108,12 @@ class Redis
 
   protected
 
-    def build_command(name, *args)
-      command = []
-      command << "*#{args.size + 1}"
-      command << "$#{string_size name}"
-      command << name
-
-      args.each do |arg|
-        arg = arg.to_s
-        command << "$#{string_size arg}"
-        command << arg
-      end
-
-      command
-    end
-
     def deprecated(old, new = nil, trace = caller[0])
       message = "The method #{old} is deprecated and will be removed in 2.0"
       message << " - use #{new} instead" if new
       Redis.deprecate(message, trace)
     end
 
-    COMMAND_DELIMITER = "\r\n"
-
-    def join_commands(commands)
-      commands.map do |command|
-        build_command(*command).join(COMMAND_DELIMITER) + COMMAND_DELIMITER
-      end.join(nil)
-    end
-
-    if "".respond_to?(:bytesize)
-      def string_size(string)
-        string.to_s.bytesize
-      end
-    else
-      def string_size(string)
-        string.to_s.size
-      end
-    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 = encode(@sock.read(bulklen))
-      @sock.read(2) # Discard CRLF.
-      reply
-    end
-
-    def format_multi_bulk_reply(line)
-      n = line.to_i
-      return if n == -1
-
-      Array.new(n) { read }
-    end
-
     def logging(commands)
       return yield unless @logger && @logger.debug?
 
@@ -214,11 +131,9 @@ class Redis
 
     def connect_to(host, port)
       with_timeout(@timeout) do
-        @sock = TCPSocket.new(host, port)
+        connection.connect(host, port)
       end
 
-      @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.
@@ -229,15 +144,7 @@ class Redis
     end
 
     def 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 Errno::ENOPROTOOPT
-      end
+      connection.timeout = Integer(timeout * 1_000_000)
     end
 
     def ensure_connected
@@ -290,15 +197,5 @@ class Redis
         Timeout.timeout(seconds, &block)
       end
     end
-
-    if defined?(Encoding::default_external)
-      def encode(string)
-        string.force_encoding(Encoding::default_external)
-      end
-    else
-      def encode(string)
-        string
-      end
-    end
   end
 end

data/lib/redis/connection.rb

@@ -0,0 +1,134 @@
+class Redis
+  class Connection
+    MINUS    = "-".freeze
+    PLUS     = "+".freeze
+    COLON    = ":".freeze
+    DOLLAR   = "$".freeze
+    ASTERISK = "*".freeze
+
+    def initialize
+      @sock = nil
+    end
+
+    def connected?
+      !! @sock
+    end
+
+    def connect(host, port)
+      @sock = TCPSocket.new(host, port)
+      @sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+    end
+
+    def disconnect
+      @sock.close
+    rescue
+    ensure
+      @sock = nil
+    end
+
+    def timeout=(usecs)
+      secs   = Integer(usecs / 1_000_000)
+      usecs  = Integer(usecs - (secs * 1_000_000)) # 0 - 999_999
+
+      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 Errno::ENOPROTOOPT
+      end
+    end
+
+    COMMAND_DELIMITER = "\r\n"
+
+    def write(command)
+      @sock.write(build_command(*command).join(COMMAND_DELIMITER))
+      @sock.write(COMMAND_DELIMITER)
+    end
+
+    def build_command(name, *args)
+      command = []
+      command << "*#{args.size + 1}"
+      command << "$#{string_size name}"
+      command << name
+
+      args.each do |arg|
+        arg = arg.to_s
+        command << "$#{string_size arg}"
+        command << arg
+      end
+
+      command
+    end
+
+    def read
+      # We read the first byte using read() mainly because gets() is
+      # immune to raw socket timeouts.
+      reply_type = @sock.read(1)
+
+      raise Errno::ECONNRESET unless reply_type
+
+      format_reply(reply_type, @sock.gets)
+    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 = encode(@sock.read(bulklen))
+      @sock.read(2) # Discard CRLF.
+      reply
+    end
+
+    def format_multi_bulk_reply(line)
+      n = line.to_i
+      return if n == -1
+
+      Array.new(n) { read }
+    end
+
+  protected
+
+    if "".respond_to?(:bytesize)
+      def string_size(string)
+        string.to_s.bytesize
+      end
+    else
+      def string_size(string)
+        string.to_s.size
+      end
+    end
+
+    if defined?(Encoding::default_external)
+      def encode(string)
+        string.force_encoding(Encoding::default_external)
+      end
+    else
+      def encode(string)
+        string
+      end
+    end
+  end
+end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: redis
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  prerelease: true
   segments: 
   - 2
+  - 1
   - 0
-  - 13
-  version: 2.0.13
+  - beta
+  version: 2.1.0.beta
 platform: ruby
 authors: 
 - Ezra Zygmuntowicz
@@ -21,7 +22,7 @@ autorequire: redis
 bindir: bin
 cert_chain: []
 
-date: 2010-11-01 00:00:00 -03:00
+date: 2010-11-04 00:00:00 -03:00
 default_executable: 
 dependencies: []
 
@@ -39,11 +40,11 @@ files:
 - Rakefile
 - lib/redis/client.rb
 - lib/redis/compat.rb
+- lib/redis/connection.rb
 - lib/redis/distributed.rb
 - lib/redis/hash_ring.rb
 - lib/redis/pipeline.rb
 - lib/redis/subscribe.rb
-- lib/redis/url.rb
 - lib/redis.rb
 has_rdoc: true
 homepage: http://github.com/ezmobius/redis-rb
@@ -65,11 +66,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: 

data/lib/redis/url.rb

@@ -1,69 +0,0 @@
-require "uri/generic"
-
-module URI
-  class Redis < Generic
-    DEFAULT_PORT = 6379
-
-    COMPONENT = [:scheme, :password, :host, :port, :db].freeze
-
-    def db
-      path[1..-1].to_i
-    end
-
-    alias password user
-
-  protected
-    def check_path(value)
-      if super(value)
-      end
-    end
-  end
-
-  @@schemes["REDIS"] = Redis
-end
-require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
-require "redis/url"
-
-class RedisURLTest < Test::Unit::TestCase
-  test "default values" do
-    uri = URI.parse("redis://localhost")
-
-    assert_equal "localhost", uri.host
-    assert_equal 6379, uri.port
-    assert_equal 0, uri.db
-    assert_equal nil, uri.password
-  end
-
-  test "password" do
-    uri = URI.parse("redis://secret@localhost")
-
-    assert_equal "localhost", uri.host
-    assert_equal 6379, uri.port
-    assert_equal 0, uri.db
-    assert_equal "secret", uri.password
-  end
-
-  test "db number" do
-    uri = URI.parse("redis://secret@localhost/15")
-
-    assert_equal "localhost", uri.host
-    assert_equal 6379, uri.port
-    assert_equal 15, uri.db
-    assert_equal "secret", uri.password
-  end
-
-  test "port" do
-    uri = URI.parse("redis://localhost:6380")
-
-    assert_equal "localhost", uri.host
-    assert_equal 6380, uri.port
-    assert_equal 0, uri.db
-    assert_equal nil, uri.password
-  end
-
-  test "to_s" do
-    uri = URI.parse("redis://secret@localhost:6380/15")
-
-    assert_equal "redis://secret@localhost:6380/15", uri.to_s
-  end
-end