redis_failover 0.1.0

data/spec/client_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+module RedisFailover
+  Client::Redis = RedisStub
+  class ClientStub < Client
+    def current_master
+      @master
+    end
+
+    def current_slaves
+      @slaves
+    end
+
+    def fetch_redis_servers
+      {
+        :master => 'localhost:6379',
+        :slaves => ['localhost:1111'],
+        :unreachable => []
+      }
+    end
+  end
+
+  describe Client do
+    let(:client) { ClientStub.new(:host => 'localhost', :port => 3000) }
+
+    describe '#build_clients' do
+      it 'properly parses master' do
+        client.current_master.to_s.should == 'localhost:6379'
+      end
+
+      it 'properly parses slaves' do
+        client.current_slaves.first.to_s.should == 'localhost:1111'
+      end
+    end
+
+    describe '#dispatch' do
+      it 'routes write operations to master' do
+        client.current_master.should_receive(:del)
+        client.del('foo')
+      end
+
+      it 'routes read operations to a slave' do
+        client.current_slaves.first.should_receive(:get)
+        client.get('foo')
+      end
+
+      it 'reconnects with redis failover server when node is unreachable' do
+        class << client
+          attr_reader :reconnected
+          def build_clients
+            @reconnected = true
+            super
+          end
+        end
+
+        client.current_master.make_unreachable!
+        client.del('foo')
+        client.reconnected.should be_true
+      end
+    end
+  end
+end

data/spec/node_manager_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+module RedisFailover
+  describe NodeManager do
+    let(:manager) { NodeManagerStub.new({}) }
+
+    describe '#nodes' do
+      it 'returns current master and slave nodes' do
+        manager.nodes.should == {
+          :master => 'master:6379',
+          :slaves => ['slave:6379'],
+          :unreachable => []
+        }
+      end
+    end
+
+    describe '#handle_unreachable' do
+      context 'slave dies' do
+        it 'moves slave to unreachable list' do
+          slave = manager.slaves.first
+          manager.force_unreachable(slave)
+          manager.nodes[:unreachable].should include(slave.to_s)
+        end
+      end
+
+      context 'master dies' do
+        before(:each) do
+          @slave = manager.slaves.first
+          @master = manager.master
+          manager.force_unreachable(@master)
+        end
+
+        it 'promotes slave to master' do
+          manager.master.should == @slave
+        end
+
+        it 'moves master to unreachable list' do
+          manager.nodes[:unreachable].should include(@master.to_s)
+        end
+      end
+    end
+
+    describe '#handle_reachable' do
+      before(:each) do
+        # force to be unreachable first
+        @slave = manager.slaves.first
+        manager.force_unreachable(@slave)
+      end
+
+      context 'slave node with a master present' do
+        it 'removes slave from unreachable list' do
+          manager.force_reachable(@slave)
+          manager.nodes[:unreachable].should be_empty
+          manager.nodes[:slaves].should include(@slave.to_s)
+        end
+      end
+
+      context 'slave node with no master present' do
+        before(:each) do
+          @master = manager.master
+          manager.force_unreachable(@master)
+        end
+
+        it 'promotes slave to master' do
+          manager.master.should be_nil
+          manager.force_reachable(@slave)
+          manager.master.should == @slave
+        end
+
+        it 'slaves list remains empty' do
+          manager.nodes[:slaves].should be_empty
+        end
+      end
+    end
+  end
+end

data/spec/node_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+module RedisFailover
+  describe Node do
+    let(:node) { Node.new(:host => 'localhost', :port => '123') }
+
+    before(:each) do
+      node.extend(RedisStubSupport)
+    end
+
+    describe '#initialize' do
+      it 'creates a new instance' do
+        node.host.should == 'localhost'
+        node.port.should == 123
+      end
+
+      it 'reports error if host missing' do
+        expect { Node.new }.to raise_error(InvalidNodeError)
+      end
+    end
+
+    describe '#ping' do
+      it 'responds properly if node is reachable' do
+        expect { node.ping }.to_not raise_error
+      end
+
+      it 'responds properly if node is unreachable' do
+        node.redis.make_unreachable!
+        expect { node.ping }.to raise_error(NodeUnreachableError)
+      end
+    end
+
+    describe '#master?' do
+      it 'responds properly if node is master' do
+        node.should be_master
+      end
+
+      it 'responds properly if node is not master' do
+        node.make_slave!(Node.new(:host => 'masterhost'))
+        node.should_not be_master
+      end
+    end
+
+
+    describe '#slave?' do
+      it 'responds properly if node is slave' do
+        node.should_not be_slave
+      end
+
+      it 'responds properly if node is not slave' do
+        node.make_master!
+        node.should be_master
+      end
+    end
+
+    describe '#wait_until_unreachable' do
+      it 'should wait until node dies' do
+        thread = Thread.new { node.wait_until_unreachable }
+        thread.should be_alive
+        node.redis.make_unreachable!
+        expect { thread.value }.to raise_error
+      end
+    end
+
+    describe '#stop_waiting' do
+      it 'should gracefully stop waiting' do
+        thread = Thread.new { node.wait_until_unreachable }
+        thread.should be_alive
+        node.stop_waiting
+        sleep 0.2
+        thread.should_not be_alive
+        thread.value.should be_nil
+      end
+    end
+  end
+end

data/spec/node_watcher_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module RedisFailover
+  class LightNodeManager
+    def initialize
+      @node_states = {}
+    end
+
+    def notify_state_change(node, state)
+      @node_states[node] = state
+    end
+
+    def state_for(node)
+      @node_states[node]
+    end
+  end
+
+  describe NodeWatcher do
+    let(:node_manager) { LightNodeManager.new }
+    let(:node) { Node.new(:host => 'host', :port => 123).extend(RedisStubSupport) }
+
+    describe '#watch' do
+      it 'properly informs manager of unreachable node' do
+        watcher = NodeWatcher.new(node_manager, node, 1)
+        watcher.watch
+        sleep(3)
+        node.redis.make_unreachable!
+        sleep(3)
+        watcher.shutdown
+        node_manager.state_for(node).should == :unreachable
+      end
+
+      it 'properly informs manager of reachable node' do
+        node_manager.notify_state_change(node, :unreachable)
+        watcher = NodeWatcher.new(node_manager, node, 1)
+        watcher.watch
+        sleep(3)
+        watcher.shutdown
+        node_manager.state_for(node).should == :reachable
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'rspec'
+require 'redis_failover'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+class NullObject
+  def method_missing(method, *args, &block)
+    self
+  end
+end
+
+RedisFailover::Util.logger = NullObject.new
+
+RSpec.configure do |config|
+end

data/spec/support/node_manager_stub.rb

@@ -0,0 +1,43 @@
+module RedisFailover
+  class NodeManagerStub < NodeManager
+    def parse_nodes
+      master = Node.new(:host => 'master')
+      slave = Node.new(:host => 'slave')
+      [master, slave].each { |node| node.extend(RedisStubSupport) }
+      master.make_master!
+      slave.make_slave!(master)
+      [master, [slave]]
+    end
+
+    def master
+      @master
+    end
+
+    def slaves
+      @slaves
+    end
+
+    def start_processing
+      @thread = Thread.new { start }
+    end
+
+    def stop_processing
+      @queue << nil
+      @thread.value
+    end
+
+    def force_unreachable(node)
+      start_processing
+      node.redis.make_unreachable!
+      notify_state_change(node, :unreachable)
+      stop_processing
+    end
+
+    def force_reachable(node)
+      start_processing
+      node.redis.make_reachable!
+      notify_state_change(node, :reachable)
+      stop_processing
+    end
+  end
+end

data/spec/support/redis_stub.rb

@@ -0,0 +1,82 @@
+require 'ostruct'
+
+module RedisFailover
+  # Test stub for Redis.
+  class RedisStub
+    class Proxy
+      def initialize(queue, opts = {})
+        @info = {:role => 'master'}
+        @queue = queue
+      end
+
+      def blpop(*args)
+        @queue.pop.tap do |value|
+          raise value if value
+        end
+      end
+
+      def del(*args)
+      end
+
+      def lpush(*args)
+        @queue << nil
+      end
+
+      def slaveof(host, port)
+        if host == 'no' && port == 'one'
+          @info[:role] = 'master'
+        else
+          @info[:role] = 'slave'
+        end
+      end
+
+      def info
+        @info.dup
+      end
+
+      def ping
+        'pong'
+      end
+    end
+
+    attr_reader :host, :port, :reachable
+    def initialize(opts = {})
+      @host = opts[:host]
+      @port = Integer(opts[:port])
+      @queue = Queue.new
+      @proxy = Proxy.new(@queue, opts)
+      @reachable = true
+    end
+
+    def method_missing(method, *args, &block)
+      if @reachable
+        @proxy.send(method, *args, &block)
+      else
+        raise Errno::ECONNREFUSED
+      end
+    end
+
+    def make_reachable!
+      @reachable = true
+    end
+
+    def make_unreachable!
+      @queue << Errno::ECONNREFUSED
+      @reachable = false
+    end
+
+    def to_s
+      "#{@host}:#{@port}"
+    end
+
+    def client
+      OpenStruct.new(:host => @host, :port => @port)
+    end
+  end
+
+  module RedisStubSupport
+    def redis
+      @redis ||= RedisStub.new(:host => @host, :port => @port)
+    end
+  end
+end

data/spec/util_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+module RedisFailover
+  describe Util do
+    describe '.symbolize_keys' do
+      it 'converts hash keys to symbols' do
+        Util.symbolize_keys('a' => 1, 'b' => 2).should == {:a => 1, :b => 2}
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: redis_failover
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Ryan LeCompte
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &70199893303420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70199893303420
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: &70199893302980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70199893302980
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: &70199893302560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70199893302560
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: &70199893302140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70199893302140
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70199893301720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70199893301720
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70199893301300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70199893301300
+description: Redis Failover provides a full automatic master/slave failover solution
+  for Ruby
+email:
+- lecompte@gmail.com
+executables:
+- redis_failover_server
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Changes.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/redis_failover_server
+- lib/redis_failover.rb
+- lib/redis_failover/cli.rb
+- lib/redis_failover/client.rb
+- lib/redis_failover/errors.rb
+- lib/redis_failover/node.rb
+- lib/redis_failover/node_manager.rb
+- lib/redis_failover/node_watcher.rb
+- lib/redis_failover/runner.rb
+- lib/redis_failover/server.rb
+- lib/redis_failover/util.rb
+- lib/redis_failover/version.rb
+- redis_failover.gemspec
+- spec/cli_spec.rb
+- spec/client_spec.rb
+- spec/node_manager_spec.rb
+- spec/node_spec.rb
+- spec/node_watcher_spec.rb
+- spec/spec_helper.rb
+- spec/support/node_manager_stub.rb
+- spec/support/redis_stub.rb
+- spec/util_spec.rb
+homepage: http://github.com/ryanlecompte/redis_failover
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1217445009113181940
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1217445009113181940
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.16
+signing_key: 
+specification_version: 3
+summary: Redis Failover provides a full automatic master/slave failover solution for
+  Ruby
+test_files:
+- spec/cli_spec.rb
+- spec/client_spec.rb
+- spec/node_manager_spec.rb
+- spec/node_spec.rb
+- spec/node_watcher_spec.rb
+- spec/spec_helper.rb
+- spec/support/node_manager_stub.rb
+- spec/support/redis_stub.rb
+- spec/util_spec.rb