replidog 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2419525361d0fe6b11f5150aa4641aaa33358978
+  data.tar.gz: 954cdd81a2a5056cf153083d3315e6d5ef39e020
+SHA512:
+  metadata.gz: 48aab863f60e64c3efc4aa8f0ca6fe64a3830e0e5b0a3efcfb8a5dd9469aae8b0a8f3c6ff9df1f4767d7afcc43db879488038625d3f51ef25f258f74d97dd1b2
+  data.tar.gz: ff4b99cd46fe00763a8f82caf7fcbf14ba9c33417bb3993799ddcd669f8fcb827ff61349db335243f68d355c3d5026227eba698f022d0dfb4a867963551ae7ac

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/dummy/log/*.log
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+gemfiles/*.gemfile.lock
+mkmf.log

data/Appraisals

@@ -0,0 +1,17 @@
+appraise "rails32" do
+    gem "activerecord", "~> 3.2.0"
+end
+
+appraise "rails4" do
+    gem "activerecord", "~> 4.0.0"
+end
+
+appraise "rails41" do
+    gem "activerecord", "~> 4.1.0"
+end
+
+appraise "rails42" do
+    gem "activerecord", "~> 4.2.0"
+end
+# vim: ft=ruby
+#

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in replidog.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Manabu Ejima
+
+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,188 @@
+# Replidog
+
+Multiple mlaster/slave helper for ActiveRecord
+
+Based on https://github.com/r7kamura/replicat
+
+## Features
+
+* Multiple master/slave
+* Auto switching between master/slave
+* Supports connection management and query cache
+* Supports Rails 3.2, 4.0, 4,1, 4.2
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'replidog'
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install replidog
+```
+
+## Usage
+
+### configuration
+
+```ruby
+# config/database.yml
+production:
+  adapter: mysql2
+  encoding: utf8
+  host: 192.168.24.1
+  port: 3306
+  replications:
+    slave1:
+      adapter: mysql2
+      encoding: utf8
+      host: 192.168.24.2
+      port: 3306
+    slave2:
+      adapter: mysql2
+      encoding: utf8
+      host: 192.168.24.3
+      port: 3306
+    slave3:
+      adapter: mysql2
+      encoding: utf8
+      host: 192.168.24.4
+      port: 3306
+```
+
+### replication
+
+Now SELECT queries of User model will be sent to slave connections.
+
+```ruby
+# INSERT query is sent to master.
+User.create(name: "replicat")
+
+# SELECT query is sent to slave.
+User.first
+```
+
+### using
+
+`using` can help you specify particular connection.
+When you want to send queries to master,
+you can use `using(:master)` to do that (:master is reserved name for `using` method).
+When you want to send queries to a particular slave,
+you can use the slave's name on database.yml like `using(:slave1)`.
+
+```ruby
+# SELECT query is sent to master.
+User.using(:master).first
+
+# INSERT query is sent to slave1.
+User.using(:slave1).create(name: "replicat")
+
+# :slave1 is used for User connection in the passed block.
+User.using(:slave1) { blog.user }
+```
+
+### round-robin
+
+slave connections are balanced by round-robin way.
+
+```ruby
+User.first # sent to slave1
+User.first # sent to slave2
+User.first # sent to slave3
+User.first # sent to slave1
+User.first # sent to slave2
+User.first # sent to slave3
+User.first # sent to slave1
+User.first # sent to slave2
+User.first # sent to slave3
+```
+
+### multi master-slave set
+
+Pass the master's connection name to `replicate` method.
+
+```ruby
+# app/models/recipe.rb
+class Recipe < RecipeTable
+  establish_connection :production_recipe
+end
+
+# config/database.yml
+production_base:
+  adapter: mysql2
+  encoding: utf8
+  port: 3306
+production:
+  <<: *production_base
+  host: 192.168.24.1
+  replications:
+    slave1:
+      <<: *slave
+      host: 192.168.24.2
+    slave2:
+      <<: *slave
+      host: 192.168.24.3
+    slave3:
+      <<: *slave
+      host: 192.168.24.4
+
+production_recipe:
+  <<: *production_base
+  host: 192.168.24.5
+  replications:
+    slave1:
+      <<: *slave
+      host: 192.168.24.6
+    slave2:
+      <<: *slave
+      host: 192.168.24.7
+    slave3:
+      <<: *slave
+      host: 192.168.24.8
+```
+
+If you want to connecto to `production_recipe` in multiple models, Create Abstract class and extend it.
+
+```ruby
+# app/models/recipe_table.rb
+class RecipeTable < ActiveRecord::Base
+  self.abstract_class = true
+  establish_connection :production_recipe
+end
+
+# app/models/recipe.rb
+class Recipe < RecipeTable
+end
+```
+
+### connection management / query cache
+
+To handle all master/slave connections togegher, the methods related with connection management and query cache are overridden.
+So you don't need to update middlewares and configurations for app servers.
+
+List of overridden methods
+* ActiveRecord::Base.clear_active_connections
+* ActiveRecord::Base.clear_reloadable_connections
+* ActiveRecord::Base.clear_all_connections
+* ActiveRecord::Base.connection.enable_query_cache!
+* ActiveRecord::Base.connection.disable_query_cache!
+* ActiveRecord::Base.connection.clear_query_cache!
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/replidog/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/gemfiles/rails32.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 3.2.0"
+
+gemspec :path => "../"

data/gemfiles/rails4.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.0.0"
+
+gemspec :path => "../"

data/gemfiles/rails41.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.1.0"
+
+gemspec :path => "../"

data/gemfiles/rails42.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 4.2.0"
+
+gemspec :path => "../"

data/lib/replidog/active_record.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.extend Replidog::Model

data/lib/replidog/model.rb

@@ -0,0 +1,89 @@
+require "active_support/core_ext/module/aliasing"
+require "active_support/core_ext/class/attribute"
+
+module Replidog
+  module Model
+    def self.extended(base)
+      base.class_attribute :proxy_handler, instance_writer: false
+      base.proxy_handler = Replidog::ProxyHandler.new
+
+      class << base
+        alias_method_chain(:establish_connection, :replidog)
+        alias_method_chain(:connection, :replidog)
+        alias_method_chain(:connected?, :replidog)
+        alias_method_chain(:clear_reloadable_connections!, :replidog)
+        alias_method_chain(:clear_active_connections!, :replidog)
+        alias_method_chain(:clear_all_connections!, :replidog)
+      end
+    end
+
+    def establish_connection_with_replidog(spec = ENV["DATABASE_URL"])
+      establish_connection_without_replidog(spec)
+      proxy_handler.remove_connection(self)
+      proxy_handler.establish_connection(connection_pool.spec, self)
+    end
+
+    def connection_with_replidog
+      if replicated?
+        proxy_handler.retrieve_proxy(self).tap do |proxy|
+          proxy.current_model = self
+        end
+      else
+        connection_without_replidog
+      end
+    end
+
+    def replicated?
+      connection_config[:replications].present?
+    end
+
+    def using(connection_name, &block)
+      if replicated?
+        _using(connection_name, &block)
+      else
+        if block_given?
+          yield
+        else
+          self
+        end
+      end
+    end
+
+    def connected_with_replidog?
+      if replicated?
+        connection.connected?
+      else
+        connected_without_replidog?
+      end
+    end
+
+    def clear_active_connections_with_replidog!
+      clear_active_connections_without_replidog!
+      proxy_handler.clear_active_slave_connections! if replicated?
+    end
+
+    def clear_reloadable_connections_with_replidog!
+      clear_reloadable_connections_without_replidog!
+      proxy_handler.clear_reloadable_slave_connections! if replicated?
+    end
+
+    def clear_all_connections_with_replidog!
+      clear_all_connections_without_replidog!
+      proxy_handler.clear_all_slave_connections! if replicated?
+    end
+
+    private
+
+    def _using(connection_name)
+      if block_given?
+        connection.current_connection_name = connection_name
+        yield
+      else
+        ScopeProxy.new(klass: self, connection_name: connection_name)
+      end
+    ensure
+      connection.current_connection_name = nil if block_given?
+    end
+
+  end
+end

data/lib/replidog/proxy.rb

@@ -0,0 +1,189 @@
+require "active_record"
+require "active_support/core_ext/object/try"
+require "active_support/core_ext/class/attribute"
+
+module Replidog
+  class Proxy
+    REPLICABLE_METHOD_NAMES = [/^select(?:_\w+)$/]
+    REPLICABLE_METHOD_NAMES_REGEXP = /\A#{Regexp.union(REPLICABLE_METHOD_NAMES)}\z/
+
+    attr_writer :index
+
+    attr_reader :configuration
+
+    def initialize(handler, configuration)
+      @handler = handler
+      @configuration = configuration
+    end
+
+    def current_model
+      Thread.current['replidog.current_model']
+    end
+
+    def current_model=(model)
+      Thread.current['replidog.current_model'] = model.is_a?(ActiveRecord::Base) ? model.class : model
+    end
+
+    def current_connection_name
+      Thread.current['replidog.current_connection_name']
+    end
+
+    def current_connection_name=(connection_name)
+      Thread.current['replidog.current_connection_name'] = connection_name
+    end
+
+    def transaction(options = {}, &block)
+      old = current_connection_name
+      self.current_connection_name ||= :master
+      current_connection.transaction(options, &block)
+    ensure
+      self.current_connection_name = old
+    end
+
+    def connected?
+      current_model.connected_without_replidog? && slave_connection_pool_table.values.any?(&:connected?)
+    end
+
+    def clear_active_slave_connections!
+      slave_connection_pool_table.each_value do |pool|
+        pool.release_connection
+      end
+    end
+
+    def clear_reloadable_slave_connections!
+      slave_connection_pool_table.each_value do |pool|
+        pool.clear_reloadable_connections!
+      end
+    end
+
+    def clear_all_slave_connections!
+      slave_connection_pool_table.each_value do |pool|
+        pool.disconnect!
+      end
+    end
+
+    def enable_query_cache!
+      @handler.enable_query_cache!
+    end
+
+    def enable_query_cache_for_slaves!
+      slave_connection_pool_table.each_value do |pool|
+        pool.connection.enable_query_cache!
+      end
+    end
+
+    def disable_query_cache!
+      @handler.disable_query_cache!
+    end
+
+    def disable_query_cache_for_slaves!
+      slave_connection_pool_table.values.each do |pool|
+        pool.connection.disable_query_cache!
+      end
+    end
+
+    def clear_query_cache
+      @handler.clear_query_cache
+    end
+
+    def clear_query_cache_for_slaves
+      slave_connection_pool_table.values.each do |pool|
+        pool.connection.clear_query_cache
+      end
+    end
+
+    private
+
+    def method_missing(method_name, *args, &block)
+      if current_connection_name
+        current_connection.send(method_name, *args, &block)
+      else
+        connection_by_method_name(method_name).send(method_name, *args, &block)
+      end
+    end
+
+    def respond_to_missing?(method, *args)
+      master_connection.respond_to?(method, *args) || super
+    end
+
+    def connection_by_method_name(method_name)
+      REPLICABLE_METHOD_NAMES_REGEXP === method_name ? slave_connection : master_connection
+    end
+
+    def current_connection
+      if current_connection_name.to_s == "master"
+        master_connection
+      else
+        slave_connection_pool_table[current_connection_name.to_s].try(:connection) or raise_connection_not_found
+      end
+    end
+
+    def master_connection
+      current_model.connection_without_replidog
+    end
+
+    def slave_connection
+      slave_connection_pool.connection
+    end
+
+    def slave_connection_pool
+      slave_connection_pool_table.values[slave_connection_index]
+    end
+
+    def replicated?
+      replications
+    end
+
+    def replications
+      @configuration.config[:replications] || []
+    end
+
+    def slave_connection_pool_table
+      @slave_connection_pools ||= replications.inject({}) do |table, (name, configuration)|
+        table.merge(name => ConnectionPoolCreater.create(configuration))
+      end
+    end
+
+    def raise_connection_not_found
+      raise StandardError, "connection #{current_connection_name} is not found"
+    end
+
+    def slave_connection_index
+      index.tap { increment_slave_connection_index }
+    end
+
+    def increment_slave_connection_index
+      self.index = (index + 1) % slave_connection_pool_table.size
+    end
+
+    def index
+      @index ||= rand(slave_connection_pool_table.size)
+    end
+
+    # Creates database connection pool from configuration Hash table.
+    class ConnectionPoolCreater
+      def self.create(*args)
+        new(*args).create
+      end
+
+      def initialize(configuration)
+        @configuration = configuration.dup
+      end
+
+      def create
+        spec =
+          if ActiveRecord::VERSION::MAJOR >= 4
+            if ActiveRecord::VERSION::MINOR < 1
+              ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(@configuration, {}).spec
+            else
+              ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new({}).spec(@configuration)
+            end
+          else
+            ActiveRecord::Base::ConnectionSpecification::Resolver.new(@configuration, {}).spec
+          end
+
+        ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec)
+      end
+    end
+  end
+end

data/lib/replidog/proxy_handler.rb

@@ -0,0 +1,68 @@
+module Replidog
+  class ProxyHandler
+    def initialize
+      @proxies = {}
+      @class_to_proxy = {}
+    end
+
+    def establish_connection(configuration, klass)
+      @proxies[configuration] ||= Proxy.new(self, configuration)
+      @class_to_proxy[klass.name] ||= @proxies[configuration]
+    end
+
+    def retrieve_proxy(klass)
+      proxy = @class_to_proxy[klass.name]
+      return proxy if proxy
+      return nil if ActiveRecord::Base == klass
+      retrieve_proxy(klass.superclass)
+    end
+
+    def remove_connection(klass)
+      proxy = @class_to_proxy.delete(klass.name)
+      return nil unless proxy
+
+      @proxies.delete(proxy.configuration)
+      proxy.clear_all_slave_connections!
+      proxy.configuration.config
+    end
+
+    def clear_active_slave_connections!
+      @proxies.each_value do |proxy|
+        proxy.clear_active_slave_connections!
+      end
+    end
+
+    def clear_reloadable_slave_connections!
+      @proxies.each_value do |proxy|
+        proxy.clear_reloadable_slave_connections!
+      end
+    end
+
+    def clear_all_slave_connections!
+      @proxies.each_value do |proxy|
+        proxy.clear_all_slave_connections!
+      end
+    end
+
+    def enable_query_cache!
+      ActiveRecord::Base.connection_handler.connection_pools.each_value do |connection_pool|
+        connection_pool.connection.enable_query_cache!
+      end
+      @proxies.each_value(&:enable_query_cache_for_slaves!)
+    end
+
+    def disable_query_cache!
+      ActiveRecord::Base.connection_handler.connection_pools.each_value do |connection_pool|
+        connection_pool.connection.disable_query_cache!
+      end
+      @proxies.each_value(&:disable_query_cache_for_slaves!)
+    end
+
+    def clear_query_cache
+      ActiveRecord::Base.connection_handler.connection_pools.each_value do |connection_pool|
+        connection_pool.connection.clear_query_cache
+      end
+      @proxies.each_value(&:clear_query_cache_for_slaves)
+    end
+  end
+end

data/lib/replidog/scope_proxy.rb

@@ -0,0 +1,24 @@
+module Replidog
+  class ScopeProxy
+    def initialize(attributes)
+      @klass = attributes[:klass]
+      @connection_name = attributes[:connection_name]
+    end
+
+    private
+
+    def method_missing(method_name, *args, &block)
+      result = using { @klass.send(method_name, *args, &block) }
+      if result.respond_to?(:scoped)
+        @klass = result
+        self
+      else
+        result
+      end
+    end
+
+    def using
+      @klass.using(@connection_name) { yield }
+    end
+  end
+end

data/lib/replidog/version.rb

@@ -0,0 +1,3 @@
+module Replidog
+  VERSION = "0.1.0"
+end

data/lib/replidog.rb

@@ -0,0 +1,7 @@
+require "active_record"
+require "replidog/model"
+require "replidog/proxy"
+require "replidog/proxy_handler"
+require "replidog/scope_proxy"
+require "replidog/version"
+require "replidog/active_record"