sidekiq-multi-redis-client 0.9.0

data/.gitignore

@@ -0,0 +1,8 @@
+
+*.gem
+
+.DS_Store
+
+Gemfile.lock
+
+.ruby-version

data/.travis.yml

@@ -0,0 +1,18 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - jruby-19mode
+  - rbx-19mode
+  - 2.0.0
+branches:
+  only:
+    - master
+notifications:
+  email:
+    recipients:
+      - kbedell@gmail.com
+matrix:
+  allow_failures:
+    - rvm: jruby-19mode
+    - rvm: rbx-19mode
+    - rvm: 2.0.0

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+
+## v0.0.1
+
+Initial Commit

data/Gemfile

@@ -0,0 +1,2 @@
+source 'http://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Kevin Bedell
+
+MIT License
+
+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.md

@@ -0,0 +1,74 @@
+# SidekiqMultiRedisClient [![Build Status](https://travis-ci.org/kevinzen/sidekiq-multi-redis-client.png?branch=master)](https://travis-ci.org/kevinzen/sidekiq-multi-redis-client)
+
+The use case for this gem is to provide automatic load-balancing and fail-over of jobs submitted to multiple redis instances, each with its own Sidekiq workers. 
+
+In our case, we had two data centers -- each of which needs to be available as backup to the other in case the data center becomes unavailable. This gem allows all jobs to automatically get submitted to the remaining data center if one becomes unavailable -- or even if just one of the redis instances goes away. If one of the redis endpoints goes away, then jobs will be submitted to the other one. 
+
+It also spreads processing across both the redis instances.
+
+The initial version of this gem/plugin as it now stands requires you to specify two redis instances (each of which will have its own worker(s)). The gem then 'round robins' submitting jobs to the two redis instances alternating between them.
+
+
+NOTE on unit tests failing. While this sentence remains here in the readme, there are failing unit tests because the travis-ci environment does not have any redis instances connected to it for testing. The tests work on my local machine when I have multiple redis instances available. The tests (for now) assume that redis is available. This will be addressed in a future release soon.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sidekiq-multi-redis-client'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sidekiq-multi-redis-client
+
+## Usage
+
+All that is required is that you specifically set the sidekiq option for *multi-redis-job* to true like below:
+
+```ruby
+
+class MultiRedisJob
+  include Sidekiq::Worker
+  sidekiq_options :multi_redis_job => true  # The client code will now submit jobs to two different redis instances!
+  def perform(x)
+  end
+end
+
+```
+
+Not including the ```:multi_redis_job => true``` line causes Sidekiq to function as it normally would.
+
+Requiring the gem in your gemfile should be sufficient to enable multi-redis client capability.
+
+## Configuring the two redis endpoints
+
+This gem requires you to specify an ARRAY of redis Connections in your redis initializer, like so:
+
+```
+REDIS_1 = Sidekiq::RedisConnection.create(:url => "redis://localhost:6379", :namespace => 'testy')
+REDIS_2 = Sidekiq::RedisConnection.create(:url => "redis://localhost:6380", :namespace => 'testy')
+REDIS_CONNECTION_POOLS = [REDIS_1, REDIS_2]
+
+SidekiqMultiRedisClient::Config.clear_redi_params
+SidekiqMultiRedisClient::Config.redi = REDIS_1_CONNECTION_POOLS
+```
+
+This version of the gem requires two redis endpoints and 'round robins' jobs between them. Future versions of this gem will add more flexibility.
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Contributors
+
+- https://github.com/kevinzen

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  #SO MUCH NOISE
+  #test.warning = true
+  test.pattern = 'test/**/test_*.rb'
+end
+
+task :default => :test

data/lib/sidekiq-multi-redis-client.rb

@@ -0,0 +1,10 @@
+require 'yaml' if RUBY_VERSION.include?('2.0.0')
+require 'sidekiq-multi-redis-client/middleware'
+require 'sidekiq-multi-redis-client/version'
+require 'sidekiq-multi-redis-client/config'
+
+module SidekiqMultiRedisClient
+  def self.config
+    SidekiqMultiRedisClient::Config
+  end
+end

data/lib/sidekiq-multi-redis-client/config.rb

@@ -0,0 +1,54 @@
+module SidekiqMultiRedisClient
+  class Config
+    def self.multi_redis_job=(multi_redis_job)
+      @multi_redis_job = multi_redis_job
+    end
+
+    def self.multi_redis_job
+      @multi_redis_job
+    end
+
+    # Redises? An Array of redis ConnectionPools
+    # 
+    def self.redi=(array_of_redis_connection_pools)
+      @current_redis = array_of_redis_connection_pools.nil? ? nil : array_of_redis_connection_pools[0]
+      @redi = array_of_redis_connection_pools
+    end
+
+    def self.redi
+      @redi
+    end
+
+    def self.current_redis
+      @current_redis
+    end
+
+    def self.current_redis=(redis_connection_pool)
+      @current_redis = redis_connection_pool
+    end
+
+    def self.next_redis_connection
+      if @redi.size == 1
+        return @redi.first
+      end
+      @current_redis = @redi.reject {|redis_conn| @current_redis == redis_conn}.first
+    end
+
+    def self.clear_redi_params
+      @current_redis = @redi = nil
+    end
+
+    def self.error_count
+      @error_count
+    end
+
+    def self.inc_error_count
+      @error_count = @error_count + 1
+    end
+
+    def self.reset_error_count
+      @error_count = 0
+    end
+
+  end
+end

data/lib/sidekiq-multi-redis-client/middleware.rb

@@ -0,0 +1,16 @@
+require 'sidekiq'
+
+Sidekiq.configure_server do |config|
+  config.client_middleware do |chain|
+    require 'sidekiq-multi-redis-client/middleware/client/multi_redis'
+    chain.add SidekiqMultiRedisClient::Middleware::Client::MultiRedis
+  end
+
+end
+
+Sidekiq.configure_client do |config|
+  config.client_middleware do |chain|
+    require 'sidekiq-multi-redis-client/middleware/client/multi_redis'
+    chain.add SidekiqMultiRedisClient::Middleware::Client::MultiRedis
+  end
+end

data/lib/sidekiq-multi-redis-client/middleware/client/multi_redis.rb

@@ -0,0 +1,64 @@
+require 'digest'
+
+module SidekiqMultiRedisClient
+  module Middleware
+    module Client
+      class MultiRedis
+
+        def call(worker_class, item, queue)
+
+          klass = worker_class_constantize(worker_class)
+          enabled = klass.get_sidekiq_options['multi_redis_job']
+
+          if enabled 
+
+            point_to_next_redis
+            
+            # If the redis we just pointed to isn't available, move to the next one.
+            # If it's not there, we error. Right now we handle only 1 or 2 redis endpoints.
+            # If they're both gone, erroring is the right thing to do.
+            if is_redis_conn_there? == false
+              point_to_next_redis
+            end
+
+            yield 
+
+          else
+            yield
+          end
+        end
+
+
+        protected
+
+        def worker_class_constantize(worker_class)
+          if worker_class.is_a?(String)
+            worker_class.constantize rescue worker_class
+          else
+            worker_class
+          end
+        end
+
+        def is_redis_conn_there?
+          is_there = false
+          begin
+            Sidekiq.redis do |c| 
+              is_there = (c.ping == 'PONG')
+            end
+          rescue
+            Sidekiq.logger.debug { "Sidekiq - MultiRedis: Redis endpoint errored responding to ping." }
+          end
+          is_there
+        end
+
+        def point_to_next_redis
+          Sidekiq.configure_client do |config|
+            next_redis_config = SidekiqMultiRedisClient::Config.next_redis_connection
+            config.redis = next_redis_config
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/sidekiq-multi-redis-client/middleware/server/multi_redis.rb

@@ -0,0 +1,21 @@
+require 'digest'
+
+module SidekiqMultiRedisClient
+  module Middleware
+    module Server
+      class MultiRedis
+        def call(worker, item, queue)
+          yield
+        ensure
+        end
+
+        protected
+
+        def logger
+          Sidekiq.logger
+        end
+
+      end
+    end
+  end
+end

data/lib/sidekiq-multi-redis-client/version.rb

@@ -0,0 +1,3 @@
+module SidekiqMultiRedisClient
+  VERSION = "0.9.0"
+end

data/sidekiq-multi-redis-client.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sidekiq-multi-redis-client/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Kevin Bedell"]
+  gem.email         = ["kbedell@gmail.com"]
+  gem.description   = gem.summary = "Allow sidekiq clients to send jobs to multiple redis instances"
+  gem.homepage      = "http://kbedell.github.com/sidekiq-multi-redis-client"
+  gem.license       = "MIT"
+
+  # gem.executables   = ['']
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- test/*`.split("\n")
+  gem.name          = "sidekiq-multi-redis-client"
+  gem.require_paths = ["lib"]
+  gem.version       = SidekiqMultiRedisClient::VERSION
+  gem.add_dependency                  'sidekiq', '~> 2.6'
+  gem.add_development_dependency      'minitest', '~> 3'
+  gem.add_development_dependency      'rake'
+  gem.add_development_dependency      'simplecov'
+end

data/test/helper.rb

@@ -0,0 +1,125 @@
+ENV['RACK_ENV'] = ENV['RAILS_ENV'] = 'test'
+if ENV.has_key?("SIMPLECOV")
+  require 'simplecov'
+  SimpleCov.start
+end
+require 'minitest/unit'
+require 'minitest/pride'
+require 'minitest/autorun'
+
+require "sidekiq"
+require 'sidekiq/util'
+require 'sidekiq/redis_connection'
+
+require 'sidekiq-multi-redis-client'
+
+Sidekiq.logger.level = Logger::ERROR
+
+class MultiRedisJob
+  include Sidekiq::Worker
+  sidekiq_options :multi_redis_job => true
+  def perform(x)
+  end
+end
+
+class PlainRedisJob
+  include Sidekiq::Worker
+  def perform(x)
+  end
+end
+
+class SingleRedisJob
+  include Sidekiq::Worker
+  sidekiq_options :multi_redis_job => false
+  def perform(x)
+  end
+end
+
+def worker_class_constantize(worker_class)
+  if worker_class.is_a?(String)
+    worker_class.constantize rescue worker_class
+  else
+    worker_class
+  end
+end
+
+def mock_redis
+  @redis = Minitest::Mock.new
+  def @redis.multi; [yield] * 2 if block_given?; end
+  def @redis.set(*); true; end
+  def @redis.sadd(*); true; end
+  def @redis.srem(*); true; end
+  def @redis.get(*); nil; end
+  def @redis.del(*); nil; end
+  def @redis.incrby(*); nil; end
+  def @redis.setex(*); true; end
+  def @redis.expire(*); true; end
+  def @redis.watch(*); true; end
+  def @redis.with_connection; yield self; end
+  def @redis.with; yield self; end
+  def @redis.exec; true; end
+  def @redis.ping; 'PONG'; end
+  Sidekiq.instance_variable_set(:@redis, @redis)
+end
+
+def unmock_redis
+  Sidekiq.instance_variable_set(:@redis, REDIS)
+end
+
+#############
+#
+# Below here setup the redis connections you are testing with. Please don't check in 
+# changes to this section. 
+
+# I use these for testing. Change for your situation if needed.
+REDIS_1 = Sidekiq::RedisConnection.create(:url => "redis://localhost:6379/15", :namespace => 'testy')
+REDIS_2 = Sidekiq::RedisConnection.create(:url => "redis://localhost:6380/15", :namespace => 'testy')
+
+# This one doesn't exist
+BAD_REDIS = Sidekiq::RedisConnection.create(:url => "redis://http://10.10.10.1:9999/1", :namespace => 'testy')
+
+REDIS_1_CONNECTION_POOLS = [REDIS_1]
+REDIS_2_CONNECTION_POOLS = [REDIS_1, REDIS_2]
+
+REDIS_ONE_BAD = [BAD_REDIS]
+REDIS_ONE_GOOD_ONE_BAD = [REDIS_1, BAD_REDIS]
+
+def initialize_redis
+  Sidekiq.configure_client do |config|
+    next_redis_config = SidekiqMultiRedisClient::Config.next_redis_connection
+    config.redis = next_redis_config
+  end
+end
+
+def setup_one_redis_conn
+  SidekiqMultiRedisClient::Config.clear_redi_params
+  SidekiqMultiRedisClient::Config.redi = REDIS_1_CONNECTION_POOLS
+end
+
+def setup_two_redis_conns
+	SidekiqMultiRedisClient::Config.clear_redi_params
+	SidekiqMultiRedisClient::Config.redi = REDIS_2_CONNECTION_POOLS
+	initialize_redis
+end
+
+def setup_redis_one_bad
+	SidekiqMultiRedisClient::Config.clear_redi_params
+	SidekiqMultiRedisClient::Config.redi = REDIS_ONE_BAD
+	initialize_redis
+end
+
+def setup_redis_one_good_one_bad
+	SidekiqMultiRedisClient::Config.clear_redi_params
+	SidekiqMultiRedisClient::Config.redi = REDIS_ONE_GOOD_ONE_BAD
+	initialize_redis
+end
+
+# Method for flushing redis queues between tests. 
+# 'rescue' is needed in case they don't really exist.
+def flush_redis_queues (array_of_connection_pools)
+	#array_of_connection_pools.each { |redis|  
+     # Sidekiq.redis = redis
+      #Sidekiq.redis {|c| c.flushdb rescue nil}
+  #}
+end
+

data/test/lib/sidekiq/test_configuration.rb

@@ -0,0 +1,76 @@
+require 'helper'
+
+class TestConfiguration < MiniTest::Unit::TestCase
+  describe 'with real redis' do
+    before do
+    end
+
+    describe "configuration options should be identifiable" do 
+      it 'determines if the job is tagged to use multi_redis_job' do
+        enabled = MultiRedisJob.get_sidekiq_options['multi_redis_job']
+        assert enabled
+      end
+
+      it 'determines if the job is tagged to use multi_redis_job' do
+        enabled = SingleRedisJob.get_sidekiq_options['multi_redis_job']
+        assert !enabled
+      end
+
+      it "determines jobs that don't include it arent multi_redis_job" do
+        enabled = PlainRedisJob.get_sidekiq_options['multi_redis_job']
+        assert !enabled
+      end
+    end
+
+    describe "figure out how many REDIS endpoints there are" do 
+      before "reset" do
+        SidekiqMultiRedisClient::Config.redi = nil
+      end
+
+      it 'knows when there are no redis instances setup' do
+        refute SidekiqMultiRedisClient::Config.redi
+      end
+
+      it 'correctly identifies the number of redis instances after setup' do
+        setup_one_redis_conn
+        assert SidekiqMultiRedisClient::Config.redi.size, 1
+
+        setup_two_redis_conns
+        assert SidekiqMultiRedisClient::Config.redi.size, 2
+      end
+
+      it 'allows you to set / reset config parameters' do
+        setup_two_redis_conns
+
+        redi = SidekiqMultiRedisClient::Config.redi
+        assert redi.size, 2
+
+        SidekiqMultiRedisClient::Config.redi = nil
+        refute SidekiqMultiRedisClient::Config.redi
+      end
+
+      it 'allows you to reset config parameters directly' do
+        setup_two_redis_conns
+
+        redi = SidekiqMultiRedisClient::Config.clear_redi_params
+        refute SidekiqMultiRedisClient::Config.redi
+      end
+
+    end
+
+    describe "configuration options should be identifiable from the string name of the class" do 
+      it 'determines if the job is tagged to use multi_redis_job' do
+        klass = worker_class_constantize("MultiRedisJob")
+        enabled = klass.get_sidekiq_options['multi_redis_job']
+        assert enabled
+      end
+
+      it 'determines if the job is tagged to use multi_redis_job' do
+        klass = worker_class_constantize("PlainRedisJob")
+        enabled = klass.get_sidekiq_options['multi_redis_job']
+        refute enabled
+      end
+    end
+
+  end
+end

data/test/lib/sidekiq/test_failed_connections.rb

@@ -0,0 +1,17 @@
+require 'helper'
+
+class TestFailedConnections < MiniTest::Unit::TestCase
+  describe 'with real redis that fails sometimes' do
+    before do
+    end
+
+    describe "should correctly know when one of the redis conns is bad" do 
+      it 'should know there are two redis connections' do
+        setup_redis_one_bad
+        mw = SidekiqMultiRedisClient::Middleware::Client::MultiRedis.new
+        mw.call(MultiRedisJob, nil, nil) { }
+      end
+    end
+
+  end
+end

data/test/lib/sidekiq/test_middleware.rb

@@ -0,0 +1,30 @@
+describe 'multi redis middleware' do
+    before do
+	  mock_redis
+      setup_two_redis_conns
+    end
+
+    after do
+	  #unmock_redis
+    end
+
+    it 'changes the redis client for each call' do
+		redis_1 = Sidekiq.redis { |c| c.client.location }
+
+	    mw = SidekiqMultiRedisClient::Middleware::Client::MultiRedis.new
+		mw.call(MultiRedisJob, nil, nil) { }
+
+		redis_2 = Sidekiq.redis { |c| c.client.location }
+		refute_equal redis_1, redis_2
+    end
+    it 'changes the redis client for each call over and over' do
+		mw = SidekiqMultiRedisClient::Middleware::Client::MultiRedis.new
+		redis_counts = {"localhost:6379" => 0, "localhost:6380" => 0}
+    	100.times {
+			mw.call(MultiRedisJob, nil, nil) { }
+			new_redis = Sidekiq.redis { |c| c.client.location }
+			redis_counts[new_redis] = redis_counts[new_redis] + 1
+	    }
+		assert_equal redis_counts["localhost:6379"], redis_counts["localhost:6380"] 
+    end
+  end

data/test/lib/sidekiq/test_redis_selection.rb

@@ -0,0 +1,104 @@
+require 'helper'
+
+class TestRedisSelection < MiniTest::Unit::TestCase
+  describe 'with real redis' do
+    before do
+    end
+
+
+    describe "should correctly work with a single endpoint" do 
+    
+      before do
+          setup_one_redis_conn
+      end
+
+      it 'should know there is only one redis connections' do
+        assert SidekiqMultiRedisClient::Config.redi.size, 1
+      end
+
+      it 'should set the first redis instance as the current one' do
+        assert SidekiqMultiRedisClient::Config.current_redis, REDIS_1_CONNECTION_POOLS[0]
+      end
+
+      it "should get the correct values for both of the redis instances" do
+        assert SidekiqMultiRedisClient::Config.redi[0], REDIS_1_CONNECTION_POOLS[0]
+      end 
+
+      it "should know when a new redis is fetched that it is the current one " do
+        next_conn = SidekiqMultiRedisClient::Config.next_redis_connection
+        curr_conn = SidekiqMultiRedisClient::Config.current_redis
+
+        assert next_conn, curr_conn
+      end 
+
+      it "should always return the same redis when asked" do
+        1..100.times do
+
+          # do some extras to make sure we're not hitting different boundaries  
+          (1 + rand(6)).times { SidekiqMultiRedisClient::Config.next_redis_connection }
+
+          # then grab the next two
+          conn1 = SidekiqMultiRedisClient::Config.next_redis_connection
+          conn2 = SidekiqMultiRedisClient::Config.next_redis_connection
+
+          # Make sure they are in the array we initialized with
+          assert_includes REDIS_1_CONNECTION_POOLS, conn1
+          assert_includes REDIS_1_CONNECTION_POOLS, conn2
+
+          # Make sure they are the same
+          assert conn1, conn2
+        end
+      end 
+
+    end
+
+    describe "should correctly identify different redis connections" do 
+	  
+      before do
+          setup_two_redis_conns
+      end
+
+      it 'should know there are two redis connections' do
+        assert SidekiqMultiRedisClient::Config.redi.size, 2
+      end
+
+      it 'should set the first redis instance as the current one' do
+        assert SidekiqMultiRedisClient::Config.current_redis, REDIS_2_CONNECTION_POOLS[0]
+      end
+
+      it "should get the correct values for both of the redis instances" do
+        assert SidekiqMultiRedisClient::Config.redi[0], REDIS_2_CONNECTION_POOLS[0]
+        assert SidekiqMultiRedisClient::Config.redi[1], REDIS_2_CONNECTION_POOLS[1]
+      end	
+
+      it "should know when a new redis is fetched that it is the current one " do
+      	next_conn = SidekiqMultiRedisClient::Config.next_redis_connection
+      	curr_conn = SidekiqMultiRedisClient::Config.current_redis
+
+        assert next_conn, curr_conn
+      end	
+
+      it "should get alternately return different ones when asked" do
+      	1..100.times do
+
+      	  # do some extras to make sure we're not hitting different boundaries 	
+	        (1 + rand(6)).times { SidekiqMultiRedisClient::Config.next_redis_connection }
+
+	        # then grab the next two
+	        conn1 = SidekiqMultiRedisClient::Config.next_redis_connection
+      	  conn2 = SidekiqMultiRedisClient::Config.next_redis_connection
+
+          # Make sure they are in the array we initialized with
+          assert_includes REDIS_2_CONNECTION_POOLS, conn1
+          assert_includes REDIS_2_CONNECTION_POOLS, conn2
+
+          # Make sure they are different
+          refute_equal conn1, conn2
+        end
+      end	
+
+    end
+
+
+  end
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: sidekiq-multi-redis-client
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.9.0
+platform: ruby
+authors:
+- Kevin Bedell
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+    none: false
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: minitest
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          Mw==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          Mw==
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
+description: Allow sidekiq clients to send jobs to multiple redis instances
+email:
+- kbedell@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/sidekiq-multi-redis-client.rb
+- lib/sidekiq-multi-redis-client/config.rb
+- lib/sidekiq-multi-redis-client/middleware.rb
+- lib/sidekiq-multi-redis-client/middleware/client/multi_redis.rb
+- lib/sidekiq-multi-redis-client/middleware/server/multi_redis.rb
+- lib/sidekiq-multi-redis-client/version.rb
+- sidekiq-multi-redis-client.gemspec
+- test/helper.rb
+- test/lib/sidekiq/test_configuration.rb
+- test/lib/sidekiq/test_failed_connections.rb
+- test/lib/sidekiq/test_middleware.rb
+- test/lib/sidekiq/test_redis_selection.rb
+homepage: http://kbedell.github.com/sidekiq-multi-redis-client
+licenses:
+- MIT
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: Allow sidekiq clients to send jobs to multiple redis instances
+test_files:
+- test/helper.rb
+- test/lib/sidekiq/test_configuration.rb
+- test/lib/sidekiq/test_failed_connections.rb
+- test/lib/sidekiq/test_middleware.rb
+- test/lib/sidekiq/test_redis_selection.rb
+has_rdoc: