redis_master_slave 0.0.1

data/CHANGELOG

@@ -0,0 +1,3 @@
+== 0.0.1 2011-03-10
+
+ * Hi.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) George Ogata
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,83 @@
+## Redis Master Slave
+
+Redis master-slave client for Ruby.
+
+Writes are directed to a master Redis server, while reads are distributed
+round-robin across any number of slaves.
+
+## Usage
+
+    require 'redis_master_slave'
+
+    client = RedisMasterSlave.new(YAML.load_file('redis.yml'))
+
+    client.set('a', 1)         # writes to master
+    client.get('a')            # reads from slaves, round-robin
+    client.master.get('a')     # reads directly from master
+    client.slaves[0].get('a')  # reads directly from first slave
+
+### Configuration
+
+The client can be configured in several ways.
+
+#### Single configuration hash
+
+Ideal for configuration via YAML file.
+
+    client = RedisMasterSlave.new(YAML.load_file('redis.yml'))
+
+Example YAML file:
+
+    master:
+      host: localhost
+      port: 6379
+    slaves:
+      - host: localhost
+        port: 6380
+      - host: localhost
+        port: 6381
+
+#### URL strings
+
+Specify the host and port for each Redis server as a URL string:
+
+    master_url = "redis://localhost:6379"
+    slave_urls = [
+      "redis://localhost:6380",
+      "redis://localhost:6381",
+    ]
+    client = RedisMasterSlave.new(master_urls, slave_urls)
+
+#### Separate master and slave configurations
+
+Specify master and slave configurations as separate hashes:
+
+    master_config = {:host => 'localhost', :port => 6379}
+    slave_configs = []
+      {:host => 'localhost', :port => 6380},
+      {:host => 'localhost', :port => 6381},
+    ]
+    client = RedisMasterSlave.new(master_config, slave_configs)
+
+Each configuration hash is passed directly to `Redis.new`.
+
+#### Redis client objects
+
+You can also pass your own Redis client objects:
+
+    master = Redis.new(:host => 'localhost', :port => 6379)
+    slave1 = Redis.new(:host => 'localhost', :port => 6380)
+    slave2 = Redis.new(:host => 'localhost', :port => 6381)
+    client = RedisMasterSlave.new(master, slave1, slave2)
+
+## Contributing
+
+ * [Bug reports.](https://github.com/oggy/redis_master_slave/issues)
+ * [Source.](https://github.com/oggy/redis_master_slave)
+ * Patches: Fork on Github, send pull request.
+   * Please include tests where practical.
+   * Leave the version alone, or bump it in a separate commit.
+
+## Copyright
+
+Copyright (c) George Ogata. See LICENSE for details.

data/Rakefile

@@ -0,0 +1 @@
+require 'ritual'

data/lib/redis_master_slave.rb

@@ -0,0 +1,14 @@
+require 'redis'
+
+module RedisMasterSlave
+  autoload :Client, 'redis_master_slave/client'
+  autoload :ReadOnly, 'redis_master_slave/read_only'
+  autoload :ReadOnlyError, 'redis_master_slave/read_only'
+
+  #
+  # Create a new client. Same as Client.new.
+  #
+  def self.new(*args, &block)
+    Client.new(*args, &block)
+  end
+end

data/lib/redis_master_slave/client.rb

@@ -0,0 +1,153 @@
+require 'uri'
+
+module RedisMasterSlave
+  #
+  # Wrapper around a pair of Redis connections, one master and one
+  # slave.
+  #
+  # Read requests are directed to the slave, others are sent to the
+  # master.
+  #
+  class Client
+    #
+    # Create a new client.
+    #
+    # +master+ and +slave+ may be URL strings, Redis client option
+    # hashes, or Redis clients.
+    #
+    def initialize(*args)
+      case args.size
+      when 1
+        config = args.first
+
+        master_config = config['master'] || config[:master]
+        slave_configs = config['slaves'] || config[:slaves]
+      when 2
+        master_config, slave_configs = *args
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 1..2)"
+      end
+
+      @master = make_client(master_config) or
+        extend ReadOnly
+      @slaves = slave_configs.map{|config| make_client(config)}
+      @index  = 0
+    end
+
+    #
+    # The master client.
+    #
+    attr_accessor :master
+
+    #
+    # The slave client.
+    #
+    attr_accessor :slaves
+
+    #
+    # Index of the slave to use for the next read.
+    #
+    attr_accessor :index
+
+    #
+    # Return the next read slave to use.
+    #
+    # Each call returns the following slave in sequence.
+    #
+    def next_slave
+      slave = slaves[index]
+      @index = (index + 1) % slaves.size
+      slave
+    end
+
+    class << self
+      private
+
+      def send_to_slave(command)
+        class_eval <<-EOS
+          def #{command}(*args, &block)
+            next_slave.#{command}(*args, &block)
+          end
+        EOS
+      end
+
+      def send_to_master(command)
+        class_eval <<-EOS
+          def #{command}(*args, &block)
+            writable_master.#{command}(*args, &block)
+          end
+        EOS
+      end
+    end
+
+    send_to_slave :dbsize
+    send_to_slave :exists
+    send_to_slave :get
+    send_to_slave :getbit
+    send_to_slave :getrange
+    send_to_slave :hexists
+    send_to_slave :hget
+    send_to_slave :hgetall
+    send_to_slave :hkeys
+    send_to_slave :hlen
+    send_to_slave :hmget
+    send_to_slave :hvals
+    send_to_slave :keys
+    send_to_slave :lindex
+    send_to_slave :llen
+    send_to_slave :lrange
+    send_to_slave :mget
+    send_to_slave :randomkey
+    send_to_slave :scard
+    send_to_slave :sdiff
+    send_to_slave :sinter
+    send_to_slave :sismember
+    send_to_slave :smembers
+    send_to_slave :sort
+    send_to_slave :srandmember
+    send_to_slave :strlen
+    send_to_slave :sunion
+    send_to_slave :ttl
+    send_to_slave :type
+    send_to_slave :zcard
+    send_to_slave :zcount
+    send_to_slave :zrange
+    send_to_slave :zrangebyscore
+    send_to_slave :zrank
+    send_to_slave :zrevrange
+    send_to_slave :zscore
+
+    # Send everything else to master.
+    def method_missing(name, *args, &block) # :nodoc:
+      if writable_master.respond_to?(name)
+        Client.send(:send_to_master, name)
+        send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    private
+
+    def make_client(config)
+      case config
+      when String
+        # URL like redis://localhost:6379.
+        uri = URI.parse(config)
+        Redis.new(:host => uri.host, :port => uri.port)
+      when Hash
+        # Hash of Redis client options (string keys ok).
+        redis_config = {}
+        config.each do |key, value|
+          redis_config[key.to_sym] = value
+        end
+        Redis.new(config)
+      else
+        # Hopefully a client object.
+        config
+      end
+    end
+
+    alias writable_master master
+  end
+end

data/lib/redis_master_slave/read_only.rb

@@ -0,0 +1,14 @@
+module RedisMasterSlave
+  #
+  # Clients with no master defined are extended with this module.
+  #
+  # Attempts to access #writable_master will raise a ReadOnly::Error.
+  #
+  module ReadOnly
+    def writable_master
+      raise ReadOnlyError, "no master available"
+    end
+  end
+
+  ReadOnlyError = Class.new(RuntimeError)
+end

data/lib/redis_master_slave/version.rb

@@ -0,0 +1,11 @@
+module RedisMasterSlave
+  VERSION = [0, 0, 1]
+
+  class << VERSION
+    include Comparable
+
+    def to_s
+      join('.')
+    end
+  end
+end

data/spec/redis_master_slave/client_spec.rb

@@ -0,0 +1,91 @@
+require 'spec/spec_helper'
+
+describe RedisMasterSlave do
+  describe "#initialize" do
+    it "should accept a single configuration hash" do
+      client = RedisMasterSlave::Client.new('redis://localhost:6479', ['redis://localhost:6480'])
+      mc, scs = client.master.client, client.slaves.map{|s| s.client}
+      [mc.host, mc.port].should == ['localhost', 6479]
+      scs.map{|sc| [sc.host, sc.port]}.should == [['localhost', 6480]]
+    end
+
+    it "should accept URI strings" do
+      client = RedisMasterSlave::Client.new('redis://localhost:6479', ['redis://localhost:6480'])
+      mc, scs = client.master.client, client.slaves.map{|s| s.client}
+      [mc.host, mc.port].should == ['localhost', 6479]
+      scs.map{|sc| [sc.host, sc.port]}.should == [['localhost', 6480]]
+    end
+
+    it "should accept Redis configuration hashes" do
+      client = RedisMasterSlave::Client.new({:host => 'localhost', :port => 6479},
+                                            [{:host => 'localhost', :port => 6480}])
+      mc, scs = client.master.client, client.slaves.map{|s| s.client}
+      [mc.host, mc.port].should == ['localhost', 6479]
+      scs.map{|sc| [sc.host, sc.port]}.should == [['localhost', 6480]]
+    end
+
+    it "should accept Redis client objects" do
+      master = Redis.new(:host => 'localhost', :port => 6479)
+      slave  = Redis.new(:host => 'localhost', :port => 6480)
+      client = RedisMasterSlave::Client.new(master, [slave])
+      client.master.should equal(master)
+      client.slaves.size.should == 1
+      client.slaves.first.should equal(slave)
+    end
+
+    it "should accept multiple slaves" do
+      master = Redis.new(:host => 'localhost', :port => 6479)
+      slave0 = Redis.new(:host => 'localhost', :port => 6480)
+      slave1 = Redis.new(:host => 'localhost', :port => 6481)
+      client = RedisMasterSlave::Client.new(master, [slave0, slave1])
+      client.master.should equal(master)
+      client.slaves.size.should == 2
+      client.slaves[0].should equal(slave0)
+      client.slaves[1].should equal(slave1)
+    end
+
+    it "should set index to 0" do
+      client = RedisMasterSlave::Client.new('redis://localhost:6479', ['redis://localhost:6480'])
+      client.index.should == 0
+    end
+
+    it "should not have a master connection if no master configuration is given" do
+      client = RedisMasterSlave::Client.new(nil, ['redis://localhost:6480'])
+      client.master.should be_nil
+    end
+  end
+
+  describe "read operations" do
+    it "should go to each slave, round-robin" do
+      client = RedisMasterSlave::Client.new(master, [slave0, slave1])
+      master.set 'a', 'am'
+      slave0.set 'a', 'a0'
+      slave1.set 'a', 'a1'
+      client.get('a').should == 'a0'
+      client.get('a').should == 'a1'
+      client.get('a').should == 'a0'
+    end
+
+    it "should work for read-only clients" do
+      client = RedisMasterSlave::Client.new(nil, [slave0])
+      slave0.set 'a', '1'
+      client.get('a').should == '1'
+    end
+  end
+
+  describe "other operations" do
+    it "should hit the master" do
+      client = RedisMasterSlave::Client.new(master, [slave0, slave1])
+      client.set 'a', 'z'
+      client.master.get('a').should == 'z'
+      client.slaves.map{|s| s.get('a')}.should == [nil, nil]
+    end
+
+    it "should raise a ReadOnlyError for read-only clients" do
+      client = RedisMasterSlave::Client.new(nil, [slave0])
+      lambda do
+        client.set 'a', '1'
+      end.should raise_error(RedisMasterSlave::ReadOnlyError)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+ROOT = File.expand_path('..', File.dirname(__FILE__))
+
+$:.unshift "#{ROOT}/lib"
+require 'redis_master_slave'
+require 'rspec'
+
+require 'spec/support/redis'
+
+RSpec.configure do |c|
+  c.include Support::Redis
+end

data/spec/support/redis.rb

@@ -0,0 +1,31 @@
+require 'erb'
+require 'tempfile'
+
+module Support
+  module Redis
+    def self.included(base)
+      base.before { connect_to_redises }
+      base.before { quit_from_redises }
+    end
+
+    def connect_to_redises
+      master_port = ENV['REDIS_MASTER_SLAVE_MASTER_PORT'] || 6479
+      slave0_port = ENV['REDIS_MASTER_SLAVE_SLAVE0_PORT'] || 6480
+      slave1_port = ENV['REDIS_MASTER_SLAVE_SLAVE1_PORT'] || 6481
+      @master = ::Redis.new(:host => 'localhost', :port => master_port)
+      @slave0  = ::Redis.new(:host => 'localhost', :port => slave0_port)
+      @slave1  = ::Redis.new(:host => 'localhost', :port => slave1_port)
+      @master.flushdb
+      @slave0.flushdb
+      @slave1.flushdb
+    end
+
+    def quit_from_redises
+      @master.quit
+      @slave0.quit
+      @slave1.quit
+    end
+
+    attr_reader :master, :slave0, :slave1
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification 
+name: redis_master_slave
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- George Ogata
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-10 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ritual
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :development
+  version_requirements: *id002
+description: 
+email: 
+- george.ogata@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- lib/redis_master_slave/client.rb
+- lib/redis_master_slave/read_only.rb
+- lib/redis_master_slave/version.rb
+- lib/redis_master_slave.rb
+- LICENSE
+- README.markdown
+- Rakefile
+- CHANGELOG
+- spec/redis_master_slave/client_spec.rb
+- spec/spec_helper.rb
+- spec/support/redis.rb
+has_rdoc: true
+homepage: http://github.com/oggy/redis_master_slave
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Redis master-slave client for Ruby.
+test_files: 
+- spec/redis_master_slave/client_spec.rb
+- spec/spec_helper.rb
+- spec/support/redis.rb